diff --git a/.gitignore b/.gitignore
index a734c76e11ed..7c8d9ce0c817 100644
--- a/.gitignore
+++ b/.gitignore
@@ -83,3 +83,37 @@ community-build/sbt-dotty-sbt
# Vulpix output files
*.check.out
+
+tastydoc/report/report\.aux
+
+tastydoc/report/report\.fdb_latexmk
+
+tastydoc/report/report\.fls
+
+tastydoc/report/report\.synctex\.gz
+
+tastydoc/report/report\.toc
+
+tastydoc/report/report\.out
+
+tastydoc/report/presentation/presentation\.aux
+
+tastydoc/report/presentation/presentation\.fdb_latexmk
+
+tastydoc/report/presentation/presentation\.fls
+
+tastydoc/report/presentation/presentation\.nav
+
+tastydoc/report/presentation/presentation\.out
+
+tastydoc/report/presentation/presentation\.snm
+
+tastydoc/report/presentation/presentation\.synctex\.gz
+
+tastydoc/report/presentation/presentation\.toc
+
+tastydoc/dotty-0\.15\.0-RC1/
+
+tastydoc/report/presentation/presentation\.vrb
+
+tastydoc/dotty-0\.16\.0-RC3/
diff --git a/build.sbt b/build.sbt
index c0ff38b603f0..ce2d153fae34 100644
--- a/build.sbt
+++ b/build.sbt
@@ -17,6 +17,8 @@ val `dotty-bench-bootstrapped` = Build.`dotty-bench-bootstrapped`
val `tasty-core` = Build.`tasty-core`
val `tasty-core-bootstrapped` = Build.`tasty-core-bootstrapped`
val `tasty-core-scala2` = Build.`tasty-core-scala2`
+val `dotty-tastydoc` = Build.`dotty-tastydoc`
+val `dotty-tastydoc-input` = Build.`dotty-tastydoc-input`
val `scala-library` = Build.`scala-library`
val `scala-compiler` = Build.`scala-compiler`
val `scala-reflect` = Build.`scala-reflect`
diff --git a/doc-tool/src/dotty/tools/dottydoc/model/comment/Comment.scala b/doc-tool/src/dotty/tools/dottydoc/model/comment/Comment.scala
index 8921d31eb066..f7b8b1308127 100644
--- a/doc-tool/src/dotty/tools/dottydoc/model/comment/Comment.scala
+++ b/doc-tool/src/dotty/tools/dottydoc/model/comment/Comment.scala
@@ -6,7 +6,7 @@ package comment
import dotty.tools.dottydoc.util.syntax._
import dotty.tools.dotc.core.Contexts.Context
import dotty.tools.dotc.util.Spans._
-import com.vladsch.flexmark.ast.{ Node => MarkdownNode }
+import com.vladsch.flexmark.util.ast.{ Node => MarkdownNode }
import HtmlParsers._
import util.MemberLookup
diff --git a/doc-tool/src/dotty/tools/dottydoc/model/comment/CommentParser.scala b/doc-tool/src/dotty/tools/dottydoc/model/comment/CommentParser.scala
index de4acb6a7999..28629098409d 100644
--- a/doc-tool/src/dotty/tools/dottydoc/model/comment/CommentParser.scala
+++ b/doc-tool/src/dotty/tools/dottydoc/model/comment/CommentParser.scala
@@ -11,7 +11,7 @@ import dotty.tools.dotc.printing.Formatting.hl
import scala.collection.mutable
import dotty.tools.dotc.config.Printers.dottydoc
import scala.util.matching.Regex
-import com.vladsch.flexmark.ast.{ Node => MarkdownNode }
+import com.vladsch.flexmark.util.ast.{ Node => MarkdownNode }
import com.vladsch.flexmark.parser.{ Parser => MarkdownParser }
trait CommentParser extends util.MemberLookup {
diff --git a/doc-tool/src/dotty/tools/dottydoc/model/comment/HtmlParsers.scala b/doc-tool/src/dotty/tools/dottydoc/model/comment/HtmlParsers.scala
index c27ac22f36b2..7245622eb970 100644
--- a/doc-tool/src/dotty/tools/dottydoc/model/comment/HtmlParsers.scala
+++ b/doc-tool/src/dotty/tools/dottydoc/model/comment/HtmlParsers.scala
@@ -8,7 +8,7 @@ import dotc.util.Spans._
import dotty.tools.dottydoc.util.syntax._
import util.MemberLookup
-import com.vladsch.flexmark.ast.{ Node => MarkdownNode }
+import com.vladsch.flexmark.util.ast.{ Node => MarkdownNode}
import com.vladsch.flexmark.html.HtmlRenderer
import com.vladsch.flexmark.parser.Parser
import com.vladsch.flexmark.util.sequence.CharSubSequence
@@ -17,7 +17,9 @@ object HtmlParsers {
implicit class StringToMarkdown(val text: String) extends AnyVal {
def toMarkdown(origin: Entity)(implicit ctx: Context): MarkdownNode = {
- import com.vladsch.flexmark.ast.{ Link, Visitor, VisitHandler, NodeVisitor }
+ import com.vladsch.flexmark.ast.Link
+ import com.vladsch.flexmark.util.ast.{Visitor, VisitHandler, NodeVisitor }
+
val inlineToHtml = InlineToHtml(origin)
@@ -149,4 +151,4 @@ object HtmlParsers {
}
}
}
-}
+}
\ No newline at end of file
diff --git a/doc-tool/src/dotty/tools/dottydoc/model/comment/MarkdownShortener.scala b/doc-tool/src/dotty/tools/dottydoc/model/comment/MarkdownShortener.scala
index 311f1e2cb70e..a38454178f75 100644
--- a/doc-tool/src/dotty/tools/dottydoc/model/comment/MarkdownShortener.scala
+++ b/doc-tool/src/dotty/tools/dottydoc/model/comment/MarkdownShortener.scala
@@ -10,6 +10,7 @@ package comment
* @note calling `shorten` **will** mutate the Markdown AST node.
*/
class MarkdownShortener {
+ import com.vladsch.flexmark.util.ast._
import com.vladsch.flexmark.ast._
def shorten(node: Node, maxLen: Int = 150): Node = {
@@ -80,4 +81,4 @@ class MarkdownShortener {
nodeVisitor.visit(node)
node
}
-}
+}
\ No newline at end of file
diff --git a/doc-tool/src/dotty/tools/dottydoc/staticsite/MarkdownCodeBlockVisitor.scala b/doc-tool/src/dotty/tools/dottydoc/staticsite/MarkdownCodeBlockVisitor.scala
index 5aeffd0d52e7..04995a8ec8d4 100644
--- a/doc-tool/src/dotty/tools/dottydoc/staticsite/MarkdownCodeBlockVisitor.scala
+++ b/doc-tool/src/dotty/tools/dottydoc/staticsite/MarkdownCodeBlockVisitor.scala
@@ -2,6 +2,7 @@ package dotty.tools
package dottydoc
package staticsite
+import com.vladsch.flexmark.util.ast._
import com.vladsch.flexmark.ast._
import com.vladsch.flexmark.util.sequence.CharSubSequence
@@ -16,4 +17,4 @@ object MarkdownCodeBlockVisitor {
})
)
.visit(node)
-}
+}
\ No newline at end of file
diff --git a/doc-tool/src/dotty/tools/dottydoc/staticsite/MarkdownLinkVisitor.scala b/doc-tool/src/dotty/tools/dottydoc/staticsite/MarkdownLinkVisitor.scala
index 7687065921a1..dc6d7d075eeb 100644
--- a/doc-tool/src/dotty/tools/dottydoc/staticsite/MarkdownLinkVisitor.scala
+++ b/doc-tool/src/dotty/tools/dottydoc/staticsite/MarkdownLinkVisitor.scala
@@ -3,6 +3,7 @@ package dottydoc
package staticsite
import com.vladsch.flexmark.ast._
+import com.vladsch.flexmark.util.ast._
import com.vladsch.flexmark.util.sequence.{BasedSequence, CharSubSequence}
import model.{Def, Package, TypeAlias, Val}
import dottydoc.util.MemberLookup
@@ -42,4 +43,4 @@ object MarkdownLinkVisitor {
})
)
.visit(node)
-}
+}
\ No newline at end of file
diff --git a/project/Build.scala b/project/Build.scala
index 14d0b9c7bc85..8bfe90f11955 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -374,6 +374,28 @@ object Build {
dottyLib + File.pathSeparator + findArtifactPath(externalDeps, "scala-library")
}
+ lazy val tastydocSettings = Seq(
+ baseDirectory in (Compile, run) := baseDirectory.value / "..",
+ baseDirectory in Test := baseDirectory.value / "..",
+ libraryDependencies +=
+ "com.novocode" % "junit-interface" % "0.11",
+ libraryDependencies ++= {
+ val flexmarkVersion = "0.42.12"
+ Seq(
+ "com.vladsch.flexmark" % "flexmark-all" % flexmarkVersion,
+ "com.vladsch.flexmark" % "flexmark-ext-gfm-tasklist" % flexmarkVersion,
+ "com.vladsch.flexmark" % "flexmark-ext-gfm-tables" % flexmarkVersion,
+ "com.vladsch.flexmark" % "flexmark-ext-autolink" % flexmarkVersion,
+ "com.vladsch.flexmark" % "flexmark-ext-anchorlink" % flexmarkVersion,
+ "com.vladsch.flexmark" % "flexmark-ext-emoji" % flexmarkVersion,
+ "com.vladsch.flexmark" % "flexmark-ext-gfm-strikethrough" % flexmarkVersion,
+ "com.vladsch.flexmark" % "flexmark-ext-yaml-front-matter" % flexmarkVersion,
+ Dependencies.`jackson-dataformat-yaml`,
+ "nl.big-o" % "liqp" % "0.6.7"
+ )
+ }
+ )
+
def dottyDocSettings(implicit mode: Mode) = Seq(
baseDirectory in (Compile, run) := baseDirectory.value / "..",
baseDirectory in Test := baseDirectory.value / "..",
@@ -414,9 +436,9 @@ object Build {
}.evaluated,
libraryDependencies ++= {
- val flexmarkVersion = "0.28.32"
+ val flexmarkVersion = "0.42.12"
Seq(
- "com.vladsch.flexmark" % "flexmark" % flexmarkVersion,
+ "com.vladsch.flexmark" % "flexmark-all" % flexmarkVersion,
"com.vladsch.flexmark" % "flexmark-ext-gfm-tasklist" % flexmarkVersion,
"com.vladsch.flexmark" % "flexmark-ext-gfm-tables" % flexmarkVersion,
"com.vladsch.flexmark" % "flexmark-ext-autolink" % flexmarkVersion,
@@ -1021,6 +1043,9 @@ object Build {
lazy val `dotty-bench` = project.in(file("bench")).asDottyBench(NonBootstrapped)
lazy val `dotty-bench-bootstrapped` = project.in(file("bench")).asDottyBench(Bootstrapped)
+ lazy val `dotty-tastydoc` = project.in(file("tastydoc")).asDottyTastydoc(Bootstrapped)
+ lazy val `dotty-tastydoc-input` = project.in(file("tastydoc/input")).asDottyTastydocInput(Bootstrapped)
+
// Depend on dotty-library so that sbt projects using dotty automatically
// depend on the dotty-library
lazy val `scala-library` = project.
@@ -1329,6 +1354,14 @@ object Build {
settings(commonBenchmarkSettings).
enablePlugins(JmhPlugin)
+ def asDottyTastydoc(implicit mode: Mode): Project = project.withCommonSettings.
+ aggregate(`dotty-tastydoc-input`).
+ dependsOn(dottyCompiler).
+ settings(tastydocSettings)
+
+ def asDottyTastydocInput(implicit mode: Mode): Project = project.withCommonSettings.
+ dependsOn(dottyCompiler)
+
def asDist(implicit mode: Mode): Project = project.
enablePlugins(PackPlugin).
withCommonSettings.
diff --git a/semanticdb/project/build.properties b/semanticdb/project/build.properties
new file mode 100644
index 000000000000..7c58a83abffb
--- /dev/null
+++ b/semanticdb/project/build.properties
@@ -0,0 +1 @@
+sbt.version=1.2.6
diff --git a/tastydoc/TODO.md b/tastydoc/TODO.md
new file mode 100644
index 000000000000..96df863c58d6
--- /dev/null
+++ b/tastydoc/TODO.md
@@ -0,0 +1,14 @@
+# Comment parsing
+## Files from dotty-doc requiring work
+* util.traversing
+ * ImplicitlyAddedFrom
+ * Fix linking for inherited method
+
+# Other
+* Check remaining TODOs/TOASKs/TOFIX
+
+# Representation
+* Id for typeparams so we can link (Do not link)
+* Alias type
+* Rework type matching + Order in type matching symbol counts...
+* Remove artifacts in packages => Will fix linking as well
\ No newline at end of file
diff --git a/tastydoc/documentation/dotty/DottyPredef$.md b/tastydoc/documentation/dotty/DottyPredef$.md
new file mode 100644
index 000000000000..43a590e33d57
--- /dev/null
+++ b/tastydoc/documentation/dotty/DottyPredef$.md
@@ -0,0 +1,41 @@
+dotty
+# object DottyPredef
+
+final object DottyPredef extends Serializable
+## Concrete Value Members:
+### assert
+@forceInline final def assert(assertion: => Boolean): Unit
+
+### assert
+@forceInline final def assert(assertion: => Boolean, message: => Any): Unit
+
+### assertFail
+def assertFail(message: => Any): Unit
+
+### assertFail
+def assertFail(): Unit
+
+### implicitly
+@forceInline final def implicitly[T](implicit ev: T): T
+
+### locally
+@forceInline def locally[T](body: => T): T
+
+### the
+inline def the[T](x: T): x
+
+### valueOf
+inline def valueOf[T]: T
+Retrieve the single value of a type with a unique inhabitant.
+
+***Example***
+```scala
+object Foo
+val foo = valueOf[Foo.type]
+// foo is Foo.type = Foo
+val bar = valueOf[23]
+// bar is 23.type = 23
+```
+
+***Group*** utilities
+
diff --git a/tastydoc/documentation/dotty/dotty.md b/tastydoc/documentation/dotty/dotty.md
new file mode 100644
index 000000000000..e5a25a0712ae
--- /dev/null
+++ b/tastydoc/documentation/dotty/dotty.md
@@ -0,0 +1,5 @@
+# Package dotty
+## Members:
+final object DottyPredef
+final val DottyPredef: DottyPredef
+
diff --git a/tastydoc/documentation/dotty/internal/StringContextMacro$.md b/tastydoc/documentation/dotty/internal/StringContextMacro$.md
new file mode 100644
index 000000000000..ea808c5a092c
--- /dev/null
+++ b/tastydoc/documentation/dotty/internal/StringContextMacro$.md
@@ -0,0 +1,9 @@
+dotty.internal
+# object StringContextMacro
+
+final object StringContextMacro extends Serializable
+## Concrete Value Members:
+### f
+inline def f(sc: => StringContext)(args: Seq[Any]): String
+Implemetation of scala.StringContext.f used in Dotty while the standard library is still not bootstrapped
+
diff --git a/tastydoc/documentation/dotty/internal/internal.md b/tastydoc/documentation/dotty/internal/internal.md
new file mode 100644
index 000000000000..45e2d1e9018c
--- /dev/null
+++ b/tastydoc/documentation/dotty/internal/internal.md
@@ -0,0 +1,5 @@
+# Package internal
+## Members:
+final object StringContextMacro
+final val StringContextMacro: StringContextMacro
+
diff --git a/tastydoc/documentation/dotty/runtime/Arrays$.md b/tastydoc/documentation/dotty/runtime/Arrays$.md
new file mode 100644
index 000000000000..48d408c1d6b1
--- /dev/null
+++ b/tastydoc/documentation/dotty/runtime/Arrays$.md
@@ -0,0 +1,21 @@
+dotty.runtime
+# object Arrays
+
+final object Arrays extends Serializable
+All but the first two operations should be short-circuited and implemented specially by
+the backend.
+
+## Concrete Value Members:
+### newArray
+def newArray[Arr](componentType: Class[Nothing <: Any], returnType: Class[Arr], dimensions: Array[Int]): Arr
+Create an array of a reference type T.
+
+### newGenericArray
+def newGenericArray[T](length: Int)(implicit tag: ClassTag[T]): Array[T]
+Creates an array of some element type determined by the given `ClassTag`
+argument. The erased type of applications of this method is `Object`.
+
+### seqToArray
+def seqToArray[T](xs: Seq[T], clazz: Class[Nothing <: Any]): Array[T]
+Convert a sequence to a Java array with element type given by `clazz`.
+
diff --git a/tastydoc/documentation/dotty/runtime/LazyVals$.md b/tastydoc/documentation/dotty/runtime/LazyVals$.md
new file mode 100644
index 000000000000..0bc6104cc7e5
--- /dev/null
+++ b/tastydoc/documentation/dotty/runtime/LazyVals$.md
@@ -0,0 +1,31 @@
+dotty.runtime
+# object LazyVals
+
+final object LazyVals extends Serializable
+Helper methods used in thread-safe lazy vals.
+
+## Concrete Type Members:
+### Names
+final object Names
+## Concrete Value Members:
+### CAS
+def CAS(t: Object, offset: Long, e: Long, v: Int, ord: Int): Boolean
+
+### STATE
+def STATE(cur: Long, ord: Int): Long
+
+### get
+def get(t: Object, off: Long): Long
+
+### getOffset
+def getOffset(clz: Class[Nothing <: Any], name: String): Long
+
+### setFlag
+def setFlag(t: Object, offset: Long, v: Int, ord: Int): Unit
+
+### wait4Notification
+def wait4Notification(t: Object, offset: Long, cur: Long, ord: Int): Unit
+
+### BITS_PER_LAZY_VAL
+final inline val BITS_PER_LAZY_VAL: 2
+
diff --git a/tastydoc/documentation/dotty/runtime/LazyVals$/Names$.md b/tastydoc/documentation/dotty/runtime/LazyVals$/Names$.md
new file mode 100644
index 000000000000..1f21ef59b04f
--- /dev/null
+++ b/tastydoc/documentation/dotty/runtime/LazyVals$/Names$.md
@@ -0,0 +1,23 @@
+dotty.runtime.LazyVals$
+# object Names
+
+final object Names extends Serializable
+## Concrete Value Members:
+### cas
+final inline val cas: CAS
+
+### get
+final inline val get: get
+
+### getOffset
+final inline val getOffset: getOffset
+
+### setFlag
+final inline val setFlag: setFlag
+
+### state
+final inline val state: STATE
+
+### wait4Notification
+final inline val wait4Notification: wait4Notification
+
diff --git a/tastydoc/documentation/dotty/runtime/LegacyApp.md b/tastydoc/documentation/dotty/runtime/LegacyApp.md
new file mode 100644
index 000000000000..aa933ecc5015
--- /dev/null
+++ b/tastydoc/documentation/dotty/runtime/LegacyApp.md
@@ -0,0 +1,11 @@
+dotty.runtime
+# class LegacyApp
+
+class LegacyApp
+Replaces the `scala.App` class which relies on `DelayedInit` functionality,
+not supported by Dotty.
+
+## Concrete Value Members:
+### main
+def main(args: Array[String]): Unit
+
diff --git a/tastydoc/documentation/dotty/runtime/runtime.md b/tastydoc/documentation/dotty/runtime/runtime.md
new file mode 100644
index 000000000000..8dc9dc88bacd
--- /dev/null
+++ b/tastydoc/documentation/dotty/runtime/runtime.md
@@ -0,0 +1,22 @@
+# Package runtime
+## Members:
+final object Arrays
+All but the first two operations should be short-circuited and implemented specially by
+the backend.
+
+final val Arrays: Arrays
+All but the first two operations should be short-circuited and implemented specially by
+the backend.
+
+
+final object LazyVals
+Helper methods used in thread-safe lazy vals.
+
+final val LazyVals: LazyVals
+Helper methods used in thread-safe lazy vals.
+
+
+class LegacyApp
+Replaces the `scala.App` class which relies on `DelayedInit` functionality,
+not supported by Dotty.
+
diff --git a/tastydoc/documentation/example/DocumentationInheritance.md b/tastydoc/documentation/example/DocumentationInheritance.md
new file mode 100644
index 000000000000..5dd101ea72ca
--- /dev/null
+++ b/tastydoc/documentation/example/DocumentationInheritance.md
@@ -0,0 +1,582 @@
+example
+# class DocumentationInheritance
+
+abstract class DocumentationInheritance[T, A <: scala.Int, B >: scala.Predef.String, X, Y] extends Documentation[T, A, B, X, Y]
+## Concrete Value Members:
+### ++
+def ++[B, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### ++:
+def ++:[B, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### ++:
+def ++:[B, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### +:
+def +:[B, That](elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### /:
+def /:[B](z: B)(op: (B, A) => B): B
+
+### :+
+def :+[B, That](elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### :\
+def :\[B](z: B)(op: (A, B) => B): B
+
+### abstractDefinition
+def abstractDefinition: Int
+
+### addString
+def addString(b: StringBuilder): StringBuilder
+
+### addString
+def addString(b: StringBuilder, sep: String): StringBuilder
+
+### addString
+def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
+
+### aggregate
+def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B
+
+### andThen
+override def andThen[C](k: (B) => C): PartialFunction[A, C]
+
+### apply
+def apply(idx: Int): T
+
+### applyOrElse
+def applyOrElse[A1, B1](x: A1, default: (A1) => B1): B1
+
+### canEqual
+override def canEqual(that: Any): Boolean
+
+### collect
+def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### collectFirst
+def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
+
+### combinations
+def combinations(n: Int): Iterator[Repr]
+
+### companion
+override def companion: GenericCompanion[[+A >: scala.Nothing <: scala.Any] => scala.collection.Seq[+A]]
+
+### compose
+@unspecialized def compose[A](g: (A) => T1): (A) => R
+
+### contains
+def contains[A1](elem: A1): Boolean
+
+### containsSlice
+def containsSlice[B](that: GenSeq[B]): Boolean
+
+### copyToArray
+override def copyToArray[B](xs: Array[B], start: Int, len: Int): Unit
+
+### copyToArray
+def copyToArray[B](xs: Array[B], start: Int): Unit
+
+### copyToArray
+def copyToArray[B](xs: Array[B]): Unit
+
+### copyToBuffer
+def copyToBuffer[B](dest: Buffer[B]): Unit
+
+### corresponds
+def corresponds[B](that: GenSeq[B])(p: (A, B) => Boolean): Boolean
+
+### count
+def count(p: (A) => Boolean): Int
+
+### defReturningInnerClass
+def defReturningInnerClass(): innerDocumentationClass
+
+### diff
+def diff[B](that: GenSeq[B]): Repr
+
+### distinct
+def distinct: Repr
+
+### docWithMd
+def docWithMd: Nothing
+An example documention with markdown formatting
+**I'm bold**
+*I'm italic*
+`some code`
+```scala
+def someScalaCode(x: String) = println("Hello " + x)
+`````````
+# Title of level 1
+# Title of level 1
+1. I'm a list
+* Multilevel List
+1. level 2
+
+1. level 2 2
+* level 1 again
+
+* multilevel try2
+ * try2 level2
+
+### drop
+override def drop(n: Int): Repr
+
+### dropRight
+def dropRight(n: Int): Repr
+
+### dropWhile
+def dropWhile(p: (A) => Boolean): Repr
+
+### endsWith
+def endsWith[B](that: GenSeq[B]): Boolean
+
+### equals
+override def equals(that: Any): Boolean
+
+### exists
+override def exists(p: (A) => Boolean): Boolean
+
+### filter
+def filter(p: (A) => Boolean): Repr
+
+### filterImpl
+private[scala] def filterImpl(p: (A) => Boolean, isFlipped: Boolean): Repr
+
+### filterNot
+def filterNot(p: (A) => Boolean): Repr
+
+### find
+override def find(p: (A) => Boolean): Option[A]
+
+### flatMap
+def flatMap[B, That](f: (A) => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### flatten
+def flatten[B](implicit asTraversable: (A) => GenTraversableOnce[B]): CC[B]
+
+### fold
+def fold[A1](z: A1)(op: (A1, A1) => A1): A1
+
+### foldLeft
+def foldLeft[B](z: B)(op: (B, A) => B): B
+
+### foldRight
+override def foldRight[B](z: B)(op: (A, B) => B): B
+
+### forall
+override def forall(p: (A) => Boolean): Boolean
+
+### foreach
+def foreach[U](f: (A) => U): Unit
+
+### functionWithType
+def functionWithType[U >: scala.Predef.String](): U
+
+### genericBuilder
+def genericBuilder[B]: Builder[B, CC[B]]
+
+### groupBy
+def groupBy[K](f: (A) => K): Map[K, Repr]
+
+### grouped
+def grouped(size: Int): Iterator[Repr]
+
+### hasDefiniteSize
+def hasDefiniteSize: Boolean
+
+### hashCode
+override def hashCode(): Int
+
+### head
+override def head: A
+
+### headOption
+def headOption: Option[A]
+
+### iAmAVar_=
+def iAmAVar_=(x$1: Nothing): Unit
+
+### indexOf
+def indexOf[B](elem: B, from: Int): Int
+
+### indexOf
+def indexOf[B](elem: B): Int
+
+### indexOfSlice
+def indexOfSlice[B](that: GenSeq[B], from: Int): Int
+
+### indexOfSlice
+def indexOfSlice[B](that: GenSeq[B]): Int
+
+### indexWhere
+def indexWhere(p: (A) => Boolean, from: Int): Int
+
+### indexWhere
+def indexWhere(p: (A) => Boolean): Int
+
+### indices
+def indices: Range
+
+### init
+def init: Repr
+
+### inits
+def inits: Iterator[Repr]
+
+### intersect
+def intersect[B](that: GenSeq[B]): Repr
+
+### isDefinedAt
+def isDefinedAt(idx: Int): Boolean
+
+### isEmpty
+override def isEmpty: Boolean
+
+### isTraversableAgain
+final def isTraversableAgain: Boolean
+
+### iterator
+def iterator: Iterator[T]
+
+### last
+def last: A
+
+### lastIndexOf
+def lastIndexOf[B](elem: B, end: Int): Int
+
+### lastIndexOf
+def lastIndexOf[B](elem: B): Int
+
+### lastIndexOfSlice
+def lastIndexOfSlice[B](that: GenSeq[B], end: Int): Int
+
+### lastIndexOfSlice
+def lastIndexOfSlice[B](that: GenSeq[B]): Int
+
+### lastIndexWhere
+def lastIndexWhere(p: (A) => Boolean, end: Int): Int
+
+### lastIndexWhere
+def lastIndexWhere(p: (A) => Boolean): Int
+
+### lastOption
+def lastOption: Option[A]
+
+### length
+override def length: Int
+
+### lengthCompare
+def lengthCompare(len: Int): Int
+
+### lift
+def lift: (A) => Option[B]
+
+### linkMethodInDoc
+def linkMethodInDoc(): Nothing
+method: [example.UserDocLinkingClass.linkMeFromUserDoc](../../example/UserDocLinkingClass.md#linkMeFromUserDoc)
+method:[example.level2.Documentation.apply](../../example/level2/Documentation.md#apply)
+class: [example.UserDocLinkingClass](../../example/UserDocLinkingClass.md)
+
+### linkingGraph
+def linkingGraph(g: Graph): Node
+
+### map
+def map[B, That](f: (A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### max
+def max[B](implicit cmp: Ordering[B]): A
+
+### maxBy
+def maxBy[B](f: (A) => B)(implicit cmp: Ordering[B]): A
+
+### methodsWithCallByName
+def methodsWithCallByName(x: => Int): Nothing
+
+### methodsWithDefault
+def methodsWithDefault(x: Int): Nothing
+
+### methodsWithImplicit
+def methodsWithImplicit(x: Int)(implicit imp: Int, notImp: String): Nothing
+
+### methodsWithParams
+def methodsWithParams(x: T, y: Int): List[Map[Int, T]]
+Test methods with params
+
+***return*** something is returned
+
+***y*** parameter 2
+
+***x*** parameter 1
+
+### min
+def min[B](implicit cmp: Ordering[B]): A
+
+### minBy
+def minBy[B](f: (A) => B)(implicit cmp: Ordering[B]): A
+
+### mkString
+def mkString: String
+
+### mkString
+def mkString(sep: String): String
+
+### mkString
+def mkString(start: String, sep: String, end: String): String
+
+### newBuilder
+protected def newBuilder: Builder[A, CC[A]]
+
+### nonEmpty
+def nonEmpty: Boolean
+
+### orElse
+def orElse[A1, B1](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
+
+### padTo
+def padTo[B, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### par
+def par: ParRepr
+
+### parCombiner
+protected override def parCombiner: Combiner[A, ParSeq[A]]
+
+### partition
+def partition(p: (A) => Boolean): (Repr, Repr)
+
+### patch
+def patch[B, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### permutations
+def permutations: Iterator[Repr]
+
+### prefixLength
+def prefixLength(p: (A) => Boolean): Int
+
+### product
+def product[B](implicit num: Numeric[B]): B
+
+### productArity
+def productArity: Int
+
+### productElement
+def productElement(n: Int): Any
+
+### productIterator
+def productIterator: Iterator[Any]
+
+### productPrefix
+def productPrefix: String
+
+### protectedMethod
+protected def protectedMethod: Nothing
+
+### reduce
+def reduce[A1](op: (A1, A1) => A1): A1
+
+### reduceLeft
+def reduceLeft[B](op: (B, A) => B): B
+
+### reduceLeftOption
+def reduceLeftOption[B](op: (B, A) => B): Option[B]
+
+### reduceOption
+def reduceOption[A1](op: (A1, A1) => A1): Option[A1]
+
+### reduceRight
+override def reduceRight[B](op: (A, B) => B): B
+
+### reduceRightOption
+def reduceRightOption[B](op: (A, B) => B): Option[B]
+
+### repr
+def repr: Repr
+
+### reverse
+def reverse: Repr
+
+### reverseIterator
+def reverseIterator: Iterator[A]
+
+### reverseMap
+def reverseMap[B, That](f: (A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### reversed
+protected def reversed: List[A]
+
+### runWith
+def runWith[U](action: (B) => U): (A) => Boolean
+
+### sameElements
+def sameElements[B](that: GenIterable[B]): Boolean
+
+### scan
+def scan[B, That](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom[Repr, B, That]): That
+
+### scanLeft
+def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### scanRight
+@migration def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### segmentLength
+def segmentLength(p: (A) => Boolean, from: Int): Int
+
+### seq
+override def seq: Seq[A]
+
+### size
+override def size: Int
+
+### sizeHintIfCheap
+private[collection] def sizeHintIfCheap: Int
+
+### slice
+override def slice(from: Int, until: Int): Repr
+
+### sliceWithKnownBound
+private[scala] def sliceWithKnownBound(from: Int, until: Int): Repr
+
+### sliceWithKnownDelta
+private[scala] def sliceWithKnownDelta(from: Int, until: Int, delta: Int): Repr
+
+### sliding
+def sliding(size: Int, step: Int): Iterator[Repr]
+
+### sliding
+def sliding(size: Int): Iterator[Repr]
+
+### sortBy
+def sortBy[B](f: (A) => B)(implicit ord: Ordering[B]): Repr
+
+### sortWith
+def sortWith(lt: (A, A) => Boolean): Repr
+
+### sorted
+def sorted[B](implicit ord: Ordering[B]): Repr
+
+### span
+def span(p: (A) => Boolean): (Repr, Repr)
+
+### splitAt
+def splitAt(n: Int): (Repr, Repr)
+
+### startsWith
+def startsWith[B](that: GenSeq[B], offset: Int): Boolean
+
+### startsWith
+def startsWith[B](that: GenSeq[B]): Boolean
+
+### stringPrefix
+def stringPrefix: String
+
+### sum
+def sum[B](implicit num: Numeric[B]): B
+
+### tail
+override def tail: Repr
+
+### tails
+def tails: Iterator[Repr]
+
+### take
+override def take(n: Int): Repr
+
+### takeRight
+def takeRight(n: Int): Repr
+
+### takeWhile
+override def takeWhile(p: (A) => Boolean): Repr
+
+### thisCollection
+protected override def thisCollection: Seq[A]
+
+### to
+override def to[Col](implicit cbf: CanBuildFrom[Nothing, A, Col[A]]): Col[A]
+
+### toArray
+def toArray[B](implicit evidence$1: ClassTag[B]): Array[B]
+
+### toBuffer
+def toBuffer[B]: Buffer[B]
+
+### toCollection
+protected override def toCollection(repr: Repr): Seq[A]
+
+### toIndexedSeq
+def toIndexedSeq: IndexedSeq[A]
+
+### toIterable
+override def toIterable: Iterable[A]
+
+### toIterator
+@deprecatedOverriding override def toIterator: Iterator[A]
+
+### toList
+def toList: List[A]
+
+### toMap
+def toMap[T, U](implicit ev: <:<[A, (T, U)]): Map[T, U]
+
+### toSeq
+override def toSeq: Seq[A]
+
+### toSet
+def toSet[B]: Set[B]
+
+### toStream
+override def toStream: Stream[A]
+
+### toString
+override def toString(): String
+
+### toTraversable
+@deprecatedOverriding def toTraversable: Traversable[A]
+
+### toVector
+def toVector: Vector[A]
+
+### transpose
+@migration def transpose[B](implicit asTraversable: (A) => GenTraversableOnce[B]): CC[CC[B]]
+
+### union
+override def union[B, That](that: GenSeq[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### unzip
+def unzip[A1, A2](implicit asPair: (A) => (A1, A2)): (CC[A1], CC[A2])
+
+### unzip3
+def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3)): (CC[A1], CC[A2], CC[A3])
+
+### updated
+def updated[B, That](index: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### useOfOutsideType
+def useOfOutsideType(): ReturnTypeClass[T]
+
+### useOfOutsideTypeInsideObject
+def useOfOutsideTypeInsideObject(): returnType
+
+### useOfSameLevelOutsideType
+def useOfSameLevelOutsideType(): SameLevelTypeLinking
+
+### view
+override def view(from: Int, until: Int): SeqView[A, Repr]
+
+### view
+override def view: AnyRef & SeqView[A, Repr]
+
+### withFilter
+def withFilter(p: (A) => Boolean): FilterMonadic[A, Repr]
+
+### zip
+def zip[A1, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That
+
+### zipAll
+def zipAll[B, A1, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That
+
+### zipWithIndex
+def zipWithIndex[A1, That](implicit bf: CanBuildFrom[Repr, (A1, Int), That]): That
+
diff --git a/tastydoc/documentation/example/ReturnObjectWithType$.md b/tastydoc/documentation/example/ReturnObjectWithType$.md
new file mode 100644
index 000000000000..a68dfca6a1f6
--- /dev/null
+++ b/tastydoc/documentation/example/ReturnObjectWithType$.md
@@ -0,0 +1,8 @@
+example
+# object ReturnObjectWithType
+
+final object ReturnObjectWithType extends Serializable
+## Concrete Type Members:
+### returnType
+type returnType: Int
+
diff --git a/tastydoc/documentation/example/ReturnTypeClass.md b/tastydoc/documentation/example/ReturnTypeClass.md
new file mode 100644
index 000000000000..124457872485
--- /dev/null
+++ b/tastydoc/documentation/example/ReturnTypeClass.md
@@ -0,0 +1,4 @@
+example
+# class ReturnTypeClass
+
+class ReturnTypeClass[T]
diff --git a/tastydoc/documentation/example/UserDocLinkingClass.md b/tastydoc/documentation/example/UserDocLinkingClass.md
new file mode 100644
index 000000000000..fd0178af70e8
--- /dev/null
+++ b/tastydoc/documentation/example/UserDocLinkingClass.md
@@ -0,0 +1,8 @@
+example
+# class UserDocLinkingClass
+
+class UserDocLinkingClass
+## Concrete Value Members:
+### linkMeFromUserDoc
+def linkMeFromUserDoc(): Nothing
+
diff --git a/tastydoc/documentation/example/example.md b/tastydoc/documentation/example/example.md
new file mode 100644
index 000000000000..9195567114fa
--- /dev/null
+++ b/tastydoc/documentation/example/example.md
@@ -0,0 +1,8 @@
+# Package example
+## Members:
+abstract class DocumentationInheritance
+class ReturnTypeClass
+final object ReturnObjectWithType
+final val ReturnObjectWithType: ReturnObjectWithType
+
+package level2
class UserDocLinkingClass
diff --git a/tastydoc/documentation/example/level2/ClassExtendingDocumentation.md b/tastydoc/documentation/example/level2/ClassExtendingDocumentation.md
new file mode 100644
index 000000000000..3da814a1be28
--- /dev/null
+++ b/tastydoc/documentation/example/level2/ClassExtendingDocumentation.md
@@ -0,0 +1,582 @@
+example.level2
+# class ClassExtendingDocumentation
+
+sealed abstract class ClassExtendingDocumentation[T, A <: scala.Int, B >: scala.Predef.String, X, Y] extends Documentation[T, A, B, X, Y]
+## Concrete Value Members:
+### ++
+def ++[B, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### ++:
+def ++:[B, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### ++:
+def ++:[B, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### +:
+def +:[B, That](elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### /:
+def /:[B](z: B)(op: (B, A) => B): B
+
+### :+
+def :+[B, That](elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### :\
+def :\[B](z: B)(op: (A, B) => B): B
+
+### abstractDefinition
+def abstractDefinition: Int
+
+### addString
+def addString(b: StringBuilder): StringBuilder
+
+### addString
+def addString(b: StringBuilder, sep: String): StringBuilder
+
+### addString
+def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
+
+### aggregate
+def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B
+
+### andThen
+override def andThen[C](k: (B) => C): PartialFunction[A, C]
+
+### apply
+def apply(idx: Int): T
+
+### applyOrElse
+def applyOrElse[A1, B1](x: A1, default: (A1) => B1): B1
+
+### canEqual
+override def canEqual(that: Any): Boolean
+
+### collect
+def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### collectFirst
+def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
+
+### combinations
+def combinations(n: Int): Iterator[Repr]
+
+### companion
+override def companion: GenericCompanion[[+A >: scala.Nothing <: scala.Any] => scala.collection.Seq[+A]]
+
+### compose
+@unspecialized def compose[A](g: (A) => T1): (A) => R
+
+### contains
+def contains[A1](elem: A1): Boolean
+
+### containsSlice
+def containsSlice[B](that: GenSeq[B]): Boolean
+
+### copyToArray
+override def copyToArray[B](xs: Array[B], start: Int, len: Int): Unit
+
+### copyToArray
+def copyToArray[B](xs: Array[B], start: Int): Unit
+
+### copyToArray
+def copyToArray[B](xs: Array[B]): Unit
+
+### copyToBuffer
+def copyToBuffer[B](dest: Buffer[B]): Unit
+
+### corresponds
+def corresponds[B](that: GenSeq[B])(p: (A, B) => Boolean): Boolean
+
+### count
+def count(p: (A) => Boolean): Int
+
+### defReturningInnerClass
+def defReturningInnerClass(): innerDocumentationClass
+
+### diff
+def diff[B](that: GenSeq[B]): Repr
+
+### distinct
+def distinct: Repr
+
+### docWithMd
+def docWithMd: Nothing
+An example documention with markdown formatting
+**I'm bold**
+*I'm italic*
+`some code`
+```scala
+def someScalaCode(x: String) = println("Hello " + x)
+`````````
+# Title of level 1
+# Title of level 1
+1. I'm a list
+* Multilevel List
+1. level 2
+
+1. level 2 2
+* level 1 again
+
+* multilevel try2
+ * try2 level2
+
+### drop
+override def drop(n: Int): Repr
+
+### dropRight
+def dropRight(n: Int): Repr
+
+### dropWhile
+def dropWhile(p: (A) => Boolean): Repr
+
+### endsWith
+def endsWith[B](that: GenSeq[B]): Boolean
+
+### equals
+override def equals(that: Any): Boolean
+
+### exists
+override def exists(p: (A) => Boolean): Boolean
+
+### filter
+def filter(p: (A) => Boolean): Repr
+
+### filterImpl
+private[scala] def filterImpl(p: (A) => Boolean, isFlipped: Boolean): Repr
+
+### filterNot
+def filterNot(p: (A) => Boolean): Repr
+
+### find
+override def find(p: (A) => Boolean): Option[A]
+
+### flatMap
+def flatMap[B, That](f: (A) => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### flatten
+def flatten[B](implicit asTraversable: (A) => GenTraversableOnce[B]): CC[B]
+
+### fold
+def fold[A1](z: A1)(op: (A1, A1) => A1): A1
+
+### foldLeft
+def foldLeft[B](z: B)(op: (B, A) => B): B
+
+### foldRight
+override def foldRight[B](z: B)(op: (A, B) => B): B
+
+### forall
+override def forall(p: (A) => Boolean): Boolean
+
+### foreach
+def foreach[U](f: (A) => U): Unit
+
+### functionWithType
+def functionWithType[U >: scala.Predef.String](): U
+
+### genericBuilder
+def genericBuilder[B]: Builder[B, CC[B]]
+
+### groupBy
+def groupBy[K](f: (A) => K): Map[K, Repr]
+
+### grouped
+def grouped(size: Int): Iterator[Repr]
+
+### hasDefiniteSize
+def hasDefiniteSize: Boolean
+
+### hashCode
+override def hashCode(): Int
+
+### head
+override def head: A
+
+### headOption
+def headOption: Option[A]
+
+### iAmAVar_=
+def iAmAVar_=(x$1: Nothing): Unit
+
+### indexOf
+def indexOf[B](elem: B, from: Int): Int
+
+### indexOf
+def indexOf[B](elem: B): Int
+
+### indexOfSlice
+def indexOfSlice[B](that: GenSeq[B], from: Int): Int
+
+### indexOfSlice
+def indexOfSlice[B](that: GenSeq[B]): Int
+
+### indexWhere
+def indexWhere(p: (A) => Boolean, from: Int): Int
+
+### indexWhere
+def indexWhere(p: (A) => Boolean): Int
+
+### indices
+def indices: Range
+
+### init
+def init: Repr
+
+### inits
+def inits: Iterator[Repr]
+
+### intersect
+def intersect[B](that: GenSeq[B]): Repr
+
+### isDefinedAt
+def isDefinedAt(idx: Int): Boolean
+
+### isEmpty
+override def isEmpty: Boolean
+
+### isTraversableAgain
+final def isTraversableAgain: Boolean
+
+### iterator
+def iterator: Iterator[T]
+
+### last
+def last: A
+
+### lastIndexOf
+def lastIndexOf[B](elem: B, end: Int): Int
+
+### lastIndexOf
+def lastIndexOf[B](elem: B): Int
+
+### lastIndexOfSlice
+def lastIndexOfSlice[B](that: GenSeq[B], end: Int): Int
+
+### lastIndexOfSlice
+def lastIndexOfSlice[B](that: GenSeq[B]): Int
+
+### lastIndexWhere
+def lastIndexWhere(p: (A) => Boolean, end: Int): Int
+
+### lastIndexWhere
+def lastIndexWhere(p: (A) => Boolean): Int
+
+### lastOption
+def lastOption: Option[A]
+
+### length
+override def length: Int
+
+### lengthCompare
+def lengthCompare(len: Int): Int
+
+### lift
+def lift: (A) => Option[B]
+
+### linkMethodInDoc
+def linkMethodInDoc(): Nothing
+method: [example.UserDocLinkingClass.linkMeFromUserDoc](../../example/UserDocLinkingClass.md#linkMeFromUserDoc)
+method:[example.level2.Documentation.apply](../../example/level2/Documentation.md#apply)
+class: [example.UserDocLinkingClass](../../example/UserDocLinkingClass.md)
+
+### linkingGraph
+def linkingGraph(g: Graph): Node
+
+### map
+def map[B, That](f: (A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### max
+def max[B](implicit cmp: Ordering[B]): A
+
+### maxBy
+def maxBy[B](f: (A) => B)(implicit cmp: Ordering[B]): A
+
+### methodsWithCallByName
+def methodsWithCallByName(x: => Int): Nothing
+
+### methodsWithDefault
+def methodsWithDefault(x: Int): Nothing
+
+### methodsWithImplicit
+def methodsWithImplicit(x: Int)(implicit imp: Int, notImp: String): Nothing
+
+### methodsWithParams
+def methodsWithParams(x: T, y: Int): List[Map[Int, T]]
+Test methods with params
+
+***return*** something is returned
+
+***y*** parameter 2
+
+***x*** parameter 1
+
+### min
+def min[B](implicit cmp: Ordering[B]): A
+
+### minBy
+def minBy[B](f: (A) => B)(implicit cmp: Ordering[B]): A
+
+### mkString
+def mkString: String
+
+### mkString
+def mkString(sep: String): String
+
+### mkString
+def mkString(start: String, sep: String, end: String): String
+
+### newBuilder
+protected def newBuilder: Builder[A, CC[A]]
+
+### nonEmpty
+def nonEmpty: Boolean
+
+### orElse
+def orElse[A1, B1](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
+
+### padTo
+def padTo[B, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### par
+def par: ParRepr
+
+### parCombiner
+protected override def parCombiner: Combiner[A, ParSeq[A]]
+
+### partition
+def partition(p: (A) => Boolean): (Repr, Repr)
+
+### patch
+def patch[B, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### permutations
+def permutations: Iterator[Repr]
+
+### prefixLength
+def prefixLength(p: (A) => Boolean): Int
+
+### product
+def product[B](implicit num: Numeric[B]): B
+
+### productArity
+def productArity: Int
+
+### productElement
+def productElement(n: Int): Any
+
+### productIterator
+def productIterator: Iterator[Any]
+
+### productPrefix
+def productPrefix: String
+
+### protectedMethod
+protected def protectedMethod: Nothing
+
+### reduce
+def reduce[A1](op: (A1, A1) => A1): A1
+
+### reduceLeft
+def reduceLeft[B](op: (B, A) => B): B
+
+### reduceLeftOption
+def reduceLeftOption[B](op: (B, A) => B): Option[B]
+
+### reduceOption
+def reduceOption[A1](op: (A1, A1) => A1): Option[A1]
+
+### reduceRight
+override def reduceRight[B](op: (A, B) => B): B
+
+### reduceRightOption
+def reduceRightOption[B](op: (A, B) => B): Option[B]
+
+### repr
+def repr: Repr
+
+### reverse
+def reverse: Repr
+
+### reverseIterator
+def reverseIterator: Iterator[A]
+
+### reverseMap
+def reverseMap[B, That](f: (A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### reversed
+protected def reversed: List[A]
+
+### runWith
+def runWith[U](action: (B) => U): (A) => Boolean
+
+### sameElements
+def sameElements[B](that: GenIterable[B]): Boolean
+
+### scan
+def scan[B, That](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom[Repr, B, That]): That
+
+### scanLeft
+def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### scanRight
+@migration def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### segmentLength
+def segmentLength(p: (A) => Boolean, from: Int): Int
+
+### seq
+override def seq: Seq[A]
+
+### size
+override def size: Int
+
+### sizeHintIfCheap
+private[collection] def sizeHintIfCheap: Int
+
+### slice
+override def slice(from: Int, until: Int): Repr
+
+### sliceWithKnownBound
+private[scala] def sliceWithKnownBound(from: Int, until: Int): Repr
+
+### sliceWithKnownDelta
+private[scala] def sliceWithKnownDelta(from: Int, until: Int, delta: Int): Repr
+
+### sliding
+def sliding(size: Int, step: Int): Iterator[Repr]
+
+### sliding
+def sliding(size: Int): Iterator[Repr]
+
+### sortBy
+def sortBy[B](f: (A) => B)(implicit ord: Ordering[B]): Repr
+
+### sortWith
+def sortWith(lt: (A, A) => Boolean): Repr
+
+### sorted
+def sorted[B](implicit ord: Ordering[B]): Repr
+
+### span
+def span(p: (A) => Boolean): (Repr, Repr)
+
+### splitAt
+def splitAt(n: Int): (Repr, Repr)
+
+### startsWith
+def startsWith[B](that: GenSeq[B], offset: Int): Boolean
+
+### startsWith
+def startsWith[B](that: GenSeq[B]): Boolean
+
+### stringPrefix
+def stringPrefix: String
+
+### sum
+def sum[B](implicit num: Numeric[B]): B
+
+### tail
+override def tail: Repr
+
+### tails
+def tails: Iterator[Repr]
+
+### take
+override def take(n: Int): Repr
+
+### takeRight
+def takeRight(n: Int): Repr
+
+### takeWhile
+override def takeWhile(p: (A) => Boolean): Repr
+
+### thisCollection
+protected override def thisCollection: Seq[A]
+
+### to
+override def to[Col](implicit cbf: CanBuildFrom[Nothing, A, Col[A]]): Col[A]
+
+### toArray
+def toArray[B](implicit evidence$1: ClassTag[B]): Array[B]
+
+### toBuffer
+def toBuffer[B]: Buffer[B]
+
+### toCollection
+protected override def toCollection(repr: Repr): Seq[A]
+
+### toIndexedSeq
+def toIndexedSeq: IndexedSeq[A]
+
+### toIterable
+override def toIterable: Iterable[A]
+
+### toIterator
+@deprecatedOverriding override def toIterator: Iterator[A]
+
+### toList
+def toList: List[A]
+
+### toMap
+def toMap[T, U](implicit ev: <:<[A, (T, U)]): Map[T, U]
+
+### toSeq
+override def toSeq: Seq[A]
+
+### toSet
+def toSet[B]: Set[B]
+
+### toStream
+override def toStream: Stream[A]
+
+### toString
+override def toString(): String
+
+### toTraversable
+@deprecatedOverriding def toTraversable: Traversable[A]
+
+### toVector
+def toVector: Vector[A]
+
+### transpose
+@migration def transpose[B](implicit asTraversable: (A) => GenTraversableOnce[B]): CC[CC[B]]
+
+### union
+override def union[B, That](that: GenSeq[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### unzip
+def unzip[A1, A2](implicit asPair: (A) => (A1, A2)): (CC[A1], CC[A2])
+
+### unzip3
+def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3)): (CC[A1], CC[A2], CC[A3])
+
+### updated
+def updated[B, That](index: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### useOfOutsideType
+def useOfOutsideType(): ReturnTypeClass[T]
+
+### useOfOutsideTypeInsideObject
+def useOfOutsideTypeInsideObject(): returnType
+
+### useOfSameLevelOutsideType
+def useOfSameLevelOutsideType(): SameLevelTypeLinking
+
+### view
+override def view(from: Int, until: Int): SeqView[A, Repr]
+
+### view
+override def view: AnyRef & SeqView[A, Repr]
+
+### withFilter
+def withFilter(p: (A) => Boolean): FilterMonadic[A, Repr]
+
+### zip
+def zip[A1, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That
+
+### zipAll
+def zipAll[B, A1, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That
+
+### zipWithIndex
+def zipWithIndex[A1, That](implicit bf: CanBuildFrom[Repr, (A1, Int), That]): That
+
diff --git a/tastydoc/documentation/example/level2/Documentation$.md b/tastydoc/documentation/example/level2/Documentation$.md
new file mode 100644
index 000000000000..445c60b9d3c1
--- /dev/null
+++ b/tastydoc/documentation/example/level2/Documentation$.md
@@ -0,0 +1,12 @@
+example.level2
+# object Documentation
+
+## Companion class Documentation
+
+final object Documentation extends Serializable
+Companion object
+
+## Concrete Value Members:
+### valInsideDocObject
+val valInsideDocObject: Nothing
+
diff --git a/tastydoc/documentation/example/level2/Documentation.md b/tastydoc/documentation/example/level2/Documentation.md
new file mode 100644
index 000000000000..9ab44afdccb9
--- /dev/null
+++ b/tastydoc/documentation/example/level2/Documentation.md
@@ -0,0 +1,653 @@
+example.level2
+# class Documentation
+
+## Companion object Documentation
+
+abstract class Documentation[T, A <: scala.Int, B >: scala.Predef.String, X, Y] extends Seq[T] with Product with Serializable
+This class is used for testing tasty doc generation
+
+***authors*** Bryan Abate
+
+***c1*** class parameter 1
+
+***c2*** class parameter 2
+
+***T*** class type parameter
+
+***Constructor*** create new object
+
+## Annotations:
+@strictfp
+## Constructors:
+Documentation(c1: String, c2: List[T])
+Documentation(ac: String)
+Auxiliary constructor
+
+***ac*** auxiliary parameter
+
+Documentation()
+Documentation(x: T)
+
+## Concrete Type Members:
+### abstractType
+type abstractType: Nothing <: Any
+
+### typeExample
+type typeExample: [X >: scala.Nothing <: scala.Any] => X <: [X >: scala.Nothing <: scala.Any] => scala.Predef.String
+
+### IAmACaseObject
+final case object IAmACaseObject
+### testObject
+final object testObject
+### Graph
+class Graph
+### IAmACaseClass
+case class IAmACaseClass
+### innerDocumentationClass
+class innerDocumentationClass
+### CaseImplementThis
+sealed trait CaseImplementThis
+## Concrete Value Members:
+### ++
+def ++[B, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### ++:
+def ++:[B, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### ++:
+def ++:[B, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### +:
+def +:[B, That](elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### /:
+def /:[B](z: B)(op: (B, A) => B): B
+
+### :+
+def :+[B, That](elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### :\
+def :\[B](z: B)(op: (A, B) => B): B
+
+### abstractDefinition
+def abstractDefinition: Int
+
+### addString
+def addString(b: StringBuilder): StringBuilder
+
+### addString
+def addString(b: StringBuilder, sep: String): StringBuilder
+
+### addString
+def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
+
+### aggregate
+def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B
+
+### andThen
+override def andThen[C](k: (B) => C): PartialFunction[A, C]
+
+### apply
+def apply(idx: Int): T
+
+### applyOrElse
+def applyOrElse[A1, B1](x: A1, default: (A1) => B1): B1
+
+### canEqual
+override def canEqual(that: Any): Boolean
+
+### collect
+def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### collectFirst
+def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
+
+### combinations
+def combinations(n: Int): Iterator[Repr]
+
+### companion
+override def companion: GenericCompanion[[+A >: scala.Nothing <: scala.Any] => scala.collection.Seq[+A]]
+
+### compose
+@unspecialized def compose[A](g: (A) => T1): (A) => R
+
+### contains
+def contains[A1](elem: A1): Boolean
+
+### containsSlice
+def containsSlice[B](that: GenSeq[B]): Boolean
+
+### copyToArray
+override def copyToArray[B](xs: Array[B], start: Int, len: Int): Unit
+
+### copyToArray
+def copyToArray[B](xs: Array[B], start: Int): Unit
+
+### copyToArray
+def copyToArray[B](xs: Array[B]): Unit
+
+### copyToBuffer
+def copyToBuffer[B](dest: Buffer[B]): Unit
+
+### corresponds
+def corresponds[B](that: GenSeq[B])(p: (A, B) => Boolean): Boolean
+
+### count
+def count(p: (A) => Boolean): Int
+
+### defReturningInnerClass
+def defReturningInnerClass(): innerDocumentationClass
+
+### diff
+def diff[B](that: GenSeq[B]): Repr
+
+### distinct
+def distinct: Repr
+
+### docWithMd
+def docWithMd: Nothing
+An example documention with markdown formatting
+**I'm bold**
+*I'm italic*
+`some code`
+```scala
+def someScalaCode(x: String) = println("Hello " + x)
+`````````
+# Title of level 1
+# Title of level 1
+1. I'm a list
+* Multilevel List
+1. level 2
+
+1. level 2 2
+* level 1 again
+
+* multilevel try2
+ * try2 level2
+
+### drop
+override def drop(n: Int): Repr
+
+### dropRight
+def dropRight(n: Int): Repr
+
+### dropWhile
+def dropWhile(p: (A) => Boolean): Repr
+
+### endsWith
+def endsWith[B](that: GenSeq[B]): Boolean
+
+### equals
+override def equals(that: Any): Boolean
+
+### exists
+override def exists(p: (A) => Boolean): Boolean
+
+### filter
+def filter(p: (A) => Boolean): Repr
+
+### filterImpl
+private[scala] def filterImpl(p: (A) => Boolean, isFlipped: Boolean): Repr
+
+### filterNot
+def filterNot(p: (A) => Boolean): Repr
+
+### find
+override def find(p: (A) => Boolean): Option[A]
+
+### flatMap
+def flatMap[B, That](f: (A) => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### flatten
+def flatten[B](implicit asTraversable: (A) => GenTraversableOnce[B]): CC[B]
+
+### fold
+def fold[A1](z: A1)(op: (A1, A1) => A1): A1
+
+### foldLeft
+def foldLeft[B](z: B)(op: (B, A) => B): B
+
+### foldRight
+override def foldRight[B](z: B)(op: (A, B) => B): B
+
+### forall
+override def forall(p: (A) => Boolean): Boolean
+
+### foreach
+def foreach[U](f: (A) => U): Unit
+
+### functionWithType
+def functionWithType[U >: scala.Predef.String](): U
+
+### genericBuilder
+def genericBuilder[B]: Builder[B, CC[B]]
+
+### groupBy
+def groupBy[K](f: (A) => K): Map[K, Repr]
+
+### grouped
+def grouped(size: Int): Iterator[Repr]
+
+### hasDefiniteSize
+def hasDefiniteSize: Boolean
+
+### hashCode
+override def hashCode(): Int
+
+### head
+override def head: A
+
+### headOption
+def headOption: Option[A]
+
+### iAmAVar_=
+def iAmAVar_=(x$1: Nothing): Unit
+
+### indexOf
+def indexOf[B](elem: B, from: Int): Int
+
+### indexOf
+def indexOf[B](elem: B): Int
+
+### indexOfSlice
+def indexOfSlice[B](that: GenSeq[B], from: Int): Int
+
+### indexOfSlice
+def indexOfSlice[B](that: GenSeq[B]): Int
+
+### indexWhere
+def indexWhere(p: (A) => Boolean, from: Int): Int
+
+### indexWhere
+def indexWhere(p: (A) => Boolean): Int
+
+### indices
+def indices: Range
+
+### init
+def init: Repr
+
+### inits
+def inits: Iterator[Repr]
+
+### intersect
+def intersect[B](that: GenSeq[B]): Repr
+
+### isDefinedAt
+def isDefinedAt(idx: Int): Boolean
+
+### isEmpty
+override def isEmpty: Boolean
+
+### isTraversableAgain
+final def isTraversableAgain: Boolean
+
+### iterator
+def iterator: Iterator[T]
+
+### last
+def last: A
+
+### lastIndexOf
+def lastIndexOf[B](elem: B, end: Int): Int
+
+### lastIndexOf
+def lastIndexOf[B](elem: B): Int
+
+### lastIndexOfSlice
+def lastIndexOfSlice[B](that: GenSeq[B], end: Int): Int
+
+### lastIndexOfSlice
+def lastIndexOfSlice[B](that: GenSeq[B]): Int
+
+### lastIndexWhere
+def lastIndexWhere(p: (A) => Boolean, end: Int): Int
+
+### lastIndexWhere
+def lastIndexWhere(p: (A) => Boolean): Int
+
+### lastOption
+def lastOption: Option[A]
+
+### length
+override def length: Int
+
+### lengthCompare
+def lengthCompare(len: Int): Int
+
+### lift
+def lift: (A) => Option[B]
+
+### linkMethodInDoc
+def linkMethodInDoc(): Nothing
+method: [example.UserDocLinkingClass.linkMeFromUserDoc](../../example/UserDocLinkingClass.md#linkMeFromUserDoc)
+method:[example.level2.Documentation.apply](../../example/level2/Documentation.md#apply)
+class: [example.UserDocLinkingClass](../../example/UserDocLinkingClass.md)
+
+### linkingGraph
+def linkingGraph(g: Graph): Node
+
+### map
+def map[B, That](f: (A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### max
+def max[B](implicit cmp: Ordering[B]): A
+
+### maxBy
+def maxBy[B](f: (A) => B)(implicit cmp: Ordering[B]): A
+
+### methodsWithCallByName
+def methodsWithCallByName(x: => Int): Nothing
+
+### methodsWithDefault
+def methodsWithDefault(x: Int): Nothing
+
+### methodsWithImplicit
+def methodsWithImplicit(x: Int)(implicit imp: Int, notImp: String): Nothing
+
+### methodsWithParams
+def methodsWithParams(x: T, y: Int): List[Map[Int, T]]
+Test methods with params
+
+***return*** something is returned
+
+***y*** parameter 2
+
+***x*** parameter 1
+
+### min
+def min[B](implicit cmp: Ordering[B]): A
+
+### minBy
+def minBy[B](f: (A) => B)(implicit cmp: Ordering[B]): A
+
+### mkString
+def mkString: String
+
+### mkString
+def mkString(sep: String): String
+
+### mkString
+def mkString(start: String, sep: String, end: String): String
+
+### newBuilder
+protected def newBuilder: Builder[A, CC[A]]
+
+### nonEmpty
+def nonEmpty: Boolean
+
+### orElse
+def orElse[A1, B1](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
+
+### padTo
+def padTo[B, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### par
+def par: ParRepr
+
+### parCombiner
+protected override def parCombiner: Combiner[A, ParSeq[A]]
+
+### partition
+def partition(p: (A) => Boolean): (Repr, Repr)
+
+### patch
+def patch[B, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### permutations
+def permutations: Iterator[Repr]
+
+### prefixLength
+def prefixLength(p: (A) => Boolean): Int
+
+### product
+def product[B](implicit num: Numeric[B]): B
+
+### productArity
+def productArity: Int
+
+### productElement
+def productElement(n: Int): Any
+
+### productIterator
+def productIterator: Iterator[Any]
+
+### productPrefix
+def productPrefix: String
+
+### protectedMethod
+protected def protectedMethod: Nothing
+
+### reduce
+def reduce[A1](op: (A1, A1) => A1): A1
+
+### reduceLeft
+def reduceLeft[B](op: (B, A) => B): B
+
+### reduceLeftOption
+def reduceLeftOption[B](op: (B, A) => B): Option[B]
+
+### reduceOption
+def reduceOption[A1](op: (A1, A1) => A1): Option[A1]
+
+### reduceRight
+override def reduceRight[B](op: (A, B) => B): B
+
+### reduceRightOption
+def reduceRightOption[B](op: (A, B) => B): Option[B]
+
+### repr
+def repr: Repr
+
+### reverse
+def reverse: Repr
+
+### reverseIterator
+def reverseIterator: Iterator[A]
+
+### reverseMap
+def reverseMap[B, That](f: (A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### reversed
+protected def reversed: List[A]
+
+### runWith
+def runWith[U](action: (B) => U): (A) => Boolean
+
+### sameElements
+def sameElements[B](that: GenIterable[B]): Boolean
+
+### scan
+def scan[B, That](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom[Repr, B, That]): That
+
+### scanLeft
+def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### scanRight
+@migration def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### segmentLength
+def segmentLength(p: (A) => Boolean, from: Int): Int
+
+### seq
+override def seq: Seq[A]
+
+### size
+override def size: Int
+
+### sizeHintIfCheap
+private[collection] def sizeHintIfCheap: Int
+
+### slice
+override def slice(from: Int, until: Int): Repr
+
+### sliceWithKnownBound
+private[scala] def sliceWithKnownBound(from: Int, until: Int): Repr
+
+### sliceWithKnownDelta
+private[scala] def sliceWithKnownDelta(from: Int, until: Int, delta: Int): Repr
+
+### sliding
+def sliding(size: Int, step: Int): Iterator[Repr]
+
+### sliding
+def sliding(size: Int): Iterator[Repr]
+
+### sortBy
+def sortBy[B](f: (A) => B)(implicit ord: Ordering[B]): Repr
+
+### sortWith
+def sortWith(lt: (A, A) => Boolean): Repr
+
+### sorted
+def sorted[B](implicit ord: Ordering[B]): Repr
+
+### span
+def span(p: (A) => Boolean): (Repr, Repr)
+
+### splitAt
+def splitAt(n: Int): (Repr, Repr)
+
+### startsWith
+def startsWith[B](that: GenSeq[B], offset: Int): Boolean
+
+### startsWith
+def startsWith[B](that: GenSeq[B]): Boolean
+
+### stringPrefix
+def stringPrefix: String
+
+### sum
+def sum[B](implicit num: Numeric[B]): B
+
+### tail
+override def tail: Repr
+
+### tails
+def tails: Iterator[Repr]
+
+### take
+override def take(n: Int): Repr
+
+### takeRight
+def takeRight(n: Int): Repr
+
+### takeWhile
+override def takeWhile(p: (A) => Boolean): Repr
+
+### thisCollection
+protected override def thisCollection: Seq[A]
+
+### to
+override def to[Col](implicit cbf: CanBuildFrom[Nothing, A, Col[A]]): Col[A]
+
+### toArray
+def toArray[B](implicit evidence$1: ClassTag[B]): Array[B]
+
+### toBuffer
+def toBuffer[B]: Buffer[B]
+
+### toCollection
+protected override def toCollection(repr: Repr): Seq[A]
+
+### toIndexedSeq
+def toIndexedSeq: IndexedSeq[A]
+
+### toIterable
+override def toIterable: Iterable[A]
+
+### toIterator
+@deprecatedOverriding override def toIterator: Iterator[A]
+
+### toList
+def toList: List[A]
+
+### toMap
+def toMap[T, U](implicit ev: <:<[A, (T, U)]): Map[T, U]
+
+### toSeq
+override def toSeq: Seq[A]
+
+### toSet
+def toSet[B]: Set[B]
+
+### toStream
+override def toStream: Stream[A]
+
+### toString
+override def toString(): String
+
+### toTraversable
+@deprecatedOverriding def toTraversable: Traversable[A]
+
+### toVector
+def toVector: Vector[A]
+
+### transpose
+@migration def transpose[B](implicit asTraversable: (A) => GenTraversableOnce[B]): CC[CC[B]]
+
+### union
+override def union[B, That](that: GenSeq[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### unzip
+def unzip[A1, A2](implicit asPair: (A) => (A1, A2)): (CC[A1], CC[A2])
+
+### unzip3
+def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3)): (CC[A1], CC[A2], CC[A3])
+
+### updated
+def updated[B, That](index: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### useOfOutsideType
+def useOfOutsideType(): ReturnTypeClass[T]
+
+### useOfOutsideTypeInsideObject
+def useOfOutsideTypeInsideObject(): returnType
+
+### useOfSameLevelOutsideType
+def useOfSameLevelOutsideType(): SameLevelTypeLinking
+
+### view
+override def view(from: Int, until: Int): SeqView[A, Repr]
+
+### view
+override def view: AnyRef & SeqView[A, Repr]
+
+### withFilter
+def withFilter(p: (A) => Boolean): FilterMonadic[A, Repr]
+
+### zip
+def zip[A1, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That
+
+### zipAll
+def zipAll[B, A1, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That
+
+### zipWithIndex
+def zipWithIndex[A1, That](implicit bf: CanBuildFrom[Repr, (A1, Int), That]): That
+
+### c2
+val c2: List[T]
+
+### complexTypeVal
+val complexTypeVal: Int | List[List[T]] & String | (Double | Int, Double) | (Int) => String
+
+### iAmAVar
+var iAmAVar: Nothing
+
+### protectedVal
+protected val protectedVal: Nothing
+
+### refinementTest
+val refinementTest: Graph{ def x: Int; def x2: innerDocumentationClass; type Y: String; val z: Boolean }
+
+### v
+@showAsInfix val v: Int
+Test value
+
+
+### valWithScopeModifier
+private[example] val valWithScopeModifier: Nothing
+
+### valWithScopeModifierThis
+protected val valWithScopeModifierThis: Nothing
+
diff --git a/tastydoc/documentation/example/level2/Documentation/CaseImplementThis.md b/tastydoc/documentation/example/level2/Documentation/CaseImplementThis.md
new file mode 100644
index 000000000000..ba7782514ab2
--- /dev/null
+++ b/tastydoc/documentation/example/level2/Documentation/CaseImplementThis.md
@@ -0,0 +1,7 @@
+example.level2.Documentation
+# trait CaseImplementThis
+
+sealed trait CaseImplementThis
+## Constructors:
+CaseImplementThis(id: Int)
+
diff --git a/tastydoc/documentation/example/level2/Documentation/Graph.md b/tastydoc/documentation/example/level2/Documentation/Graph.md
new file mode 100644
index 000000000000..54bb76cb808f
--- /dev/null
+++ b/tastydoc/documentation/example/level2/Documentation/Graph.md
@@ -0,0 +1,8 @@
+example.level2.Documentation
+# class Graph
+
+class Graph
+## Concrete Type Members:
+### Node
+type Node: Int
+
diff --git a/tastydoc/documentation/example/level2/Documentation/IAmACaseClass.md b/tastydoc/documentation/example/level2/Documentation/IAmACaseClass.md
new file mode 100644
index 000000000000..0e54f6fb5077
--- /dev/null
+++ b/tastydoc/documentation/example/level2/Documentation/IAmACaseClass.md
@@ -0,0 +1,19 @@
+example.level2.Documentation
+# case class IAmACaseClass
+
+## Companion object IAmACaseClass
+
+case class IAmACaseClass extends CaseImplementThis with Product with Serializable
+## Constructors:
+IAmACaseClass(x: T, id: Int)
+
+## Concrete Value Members:
+### productIterator
+def productIterator: Iterator[Any]
+
+### id
+val id: Int
+
+### x
+val x: T
+
diff --git a/tastydoc/documentation/example/level2/Documentation/IAmACaseObject$.md b/tastydoc/documentation/example/level2/Documentation/IAmACaseObject$.md
new file mode 100644
index 000000000000..7b0290519fea
--- /dev/null
+++ b/tastydoc/documentation/example/level2/Documentation/IAmACaseObject$.md
@@ -0,0 +1,11 @@
+example.level2.Documentation
+# case object IAmACaseObject
+
+final case object IAmACaseObject extends CaseImplementThis with Product with Serializable with Singleton
+## Concrete Value Members:
+### fromProduct
+def fromProduct(p: Product): MirroredMonoType
+
+### productIterator
+def productIterator: Iterator[Any]
+
diff --git a/tastydoc/documentation/example/level2/Documentation/innerDocumentationClass.md b/tastydoc/documentation/example/level2/Documentation/innerDocumentationClass.md
new file mode 100644
index 000000000000..e89829c6ed64
--- /dev/null
+++ b/tastydoc/documentation/example/level2/Documentation/innerDocumentationClass.md
@@ -0,0 +1,4 @@
+example.level2.Documentation
+# class innerDocumentationClass
+
+class innerDocumentationClass
diff --git a/tastydoc/documentation/example/level2/Documentation/testObject$.md b/tastydoc/documentation/example/level2/Documentation/testObject$.md
new file mode 100644
index 000000000000..0096a91e8e57
--- /dev/null
+++ b/tastydoc/documentation/example/level2/Documentation/testObject$.md
@@ -0,0 +1,4 @@
+example.level2.Documentation
+# object testObject
+
+final object testObject extends Serializable
diff --git a/tastydoc/documentation/example/level2/SameLevelTypeLinking.md b/tastydoc/documentation/example/level2/SameLevelTypeLinking.md
new file mode 100644
index 000000000000..18beaf006cb6
--- /dev/null
+++ b/tastydoc/documentation/example/level2/SameLevelTypeLinking.md
@@ -0,0 +1,4 @@
+example.level2
+# class SameLevelTypeLinking
+
+class SameLevelTypeLinking
diff --git a/tastydoc/documentation/example/level2/TraitWithCompanion$.md b/tastydoc/documentation/example/level2/TraitWithCompanion$.md
new file mode 100644
index 000000000000..f5791197f36c
--- /dev/null
+++ b/tastydoc/documentation/example/level2/TraitWithCompanion$.md
@@ -0,0 +1,6 @@
+example.level2
+# object TraitWithCompanion
+
+## Companion trait TraitWithCompanion
+
+final object TraitWithCompanion extends Serializable
diff --git a/tastydoc/documentation/example/level2/TraitWithCompanion.md b/tastydoc/documentation/example/level2/TraitWithCompanion.md
new file mode 100644
index 000000000000..3d3734562242
--- /dev/null
+++ b/tastydoc/documentation/example/level2/TraitWithCompanion.md
@@ -0,0 +1,6 @@
+example.level2
+# trait TraitWithCompanion
+
+## Companion object TraitWithCompanion
+
+trait TraitWithCompanion
diff --git a/tastydoc/documentation/example/level2/level2.md b/tastydoc/documentation/example/level2/level2.md
new file mode 100644
index 000000000000..b00ac5c79996
--- /dev/null
+++ b/tastydoc/documentation/example/level2/level2.md
@@ -0,0 +1,28 @@
+# Package level2
+## Members:
+final object Documentation
+Companion object
+
+final val Documentation: Documentation
+Companion object
+
+
+@strictfp abstract class Documentation
+This class is used for testing tasty doc generation
+
+***authors*** Bryan Abate
+
+***c1*** class parameter 1
+
+***c2*** class parameter 2
+
+***T*** class type parameter
+
+***Constructor*** create new object
+
+sealed abstract class ClassExtendingDocumentation
+class SameLevelTypeLinking
+final object TraitWithCompanion
+final val TraitWithCompanion: TraitWithCompanion
+
+trait TraitWithCompanion
diff --git a/tastydoc/documentation/example/level2/level3/level4/ClassLevel4.md b/tastydoc/documentation/example/level2/level3/level4/ClassLevel4.md
new file mode 100644
index 000000000000..fcc7485e2190
--- /dev/null
+++ b/tastydoc/documentation/example/level2/level3/level4/ClassLevel4.md
@@ -0,0 +1,588 @@
+example.level2.level3.level4
+# class ClassLevel4
+
+sealed abstract class ClassLevel4[T, A <: scala.Int, B >: scala.Predef.String, X, Y] extends Documentation[T, A, B, X, Y]
+## Concrete Value Members:
+### ++
+def ++[B, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### ++:
+def ++:[B, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### ++:
+def ++:[B, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### +:
+def +:[B, That](elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### /:
+def /:[B](z: B)(op: (B, A) => B): B
+
+### :+
+def :+[B, That](elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### :\
+def :\[B](z: B)(op: (A, B) => B): B
+
+### abstractDefinition
+def abstractDefinition: Int
+
+### addString
+def addString(b: StringBuilder): StringBuilder
+
+### addString
+def addString(b: StringBuilder, sep: String): StringBuilder
+
+### addString
+def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
+
+### aggregate
+def aggregate[B](z: => B)(seqop: (B, A) => B, combop: (B, B) => B): B
+
+### andThen
+override def andThen[C](k: (B) => C): PartialFunction[A, C]
+
+### apply
+def apply(idx: Int): T
+
+### applyOrElse
+def applyOrElse[A1, B1](x: A1, default: (A1) => B1): B1
+
+### canEqual
+override def canEqual(that: Any): Boolean
+
+### collect
+def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### collectFirst
+def collectFirst[B](pf: PartialFunction[A, B]): Option[B]
+
+### combinations
+def combinations(n: Int): Iterator[Repr]
+
+### companion
+override def companion: GenericCompanion[[+A >: scala.Nothing <: scala.Any] => scala.collection.Seq[+A]]
+
+### compose
+@unspecialized def compose[A](g: (A) => T1): (A) => R
+
+### contains
+def contains[A1](elem: A1): Boolean
+
+### containsSlice
+def containsSlice[B](that: GenSeq[B]): Boolean
+
+### copyToArray
+override def copyToArray[B](xs: Array[B], start: Int, len: Int): Unit
+
+### copyToArray
+def copyToArray[B](xs: Array[B], start: Int): Unit
+
+### copyToArray
+def copyToArray[B](xs: Array[B]): Unit
+
+### copyToBuffer
+def copyToBuffer[B](dest: Buffer[B]): Unit
+
+### corresponds
+def corresponds[B](that: GenSeq[B])(p: (A, B) => Boolean): Boolean
+
+### count
+def count(p: (A) => Boolean): Int
+
+### defReturningInnerClass
+def defReturningInnerClass(): innerDocumentationClass
+
+### diff
+def diff[B](that: GenSeq[B]): Repr
+
+### distinct
+def distinct: Repr
+
+### docWithMd
+def docWithMd: Nothing
+An example documention with markdown formatting
+**I'm bold**
+*I'm italic*
+`some code`
+```scala
+def someScalaCode(x: String) = println("Hello " + x)
+`````````
+# Title of level 1
+# Title of level 1
+1. I'm a list
+* Multilevel List
+1. level 2
+
+1. level 2 2
+* level 1 again
+
+* multilevel try2
+ * try2 level2
+
+### drop
+override def drop(n: Int): Repr
+
+### dropRight
+def dropRight(n: Int): Repr
+
+### dropWhile
+def dropWhile(p: (A) => Boolean): Repr
+
+### endsWith
+def endsWith[B](that: GenSeq[B]): Boolean
+
+### equals
+override def equals(that: Any): Boolean
+
+### exists
+override def exists(p: (A) => Boolean): Boolean
+
+### filter
+def filter(p: (A) => Boolean): Repr
+
+### filterImpl
+private[scala] def filterImpl(p: (A) => Boolean, isFlipped: Boolean): Repr
+
+### filterNot
+def filterNot(p: (A) => Boolean): Repr
+
+### find
+override def find(p: (A) => Boolean): Option[A]
+
+### flatMap
+def flatMap[B, That](f: (A) => GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### flatten
+def flatten[B](implicit asTraversable: (A) => GenTraversableOnce[B]): CC[B]
+
+### fold
+def fold[A1](z: A1)(op: (A1, A1) => A1): A1
+
+### foldLeft
+def foldLeft[B](z: B)(op: (B, A) => B): B
+
+### foldRight
+override def foldRight[B](z: B)(op: (A, B) => B): B
+
+### forall
+override def forall(p: (A) => Boolean): Boolean
+
+### foreach
+def foreach[U](f: (A) => U): Unit
+
+### functionWithType
+def functionWithType[U >: scala.Predef.String](): U
+
+### genericBuilder
+def genericBuilder[B]: Builder[B, CC[B]]
+
+### groupBy
+def groupBy[K](f: (A) => K): Map[K, Repr]
+
+### grouped
+def grouped(size: Int): Iterator[Repr]
+
+### hasDefiniteSize
+def hasDefiniteSize: Boolean
+
+### hashCode
+override def hashCode(): Int
+
+### head
+override def head: A
+
+### headOption
+def headOption: Option[A]
+
+### iAmAVar_=
+def iAmAVar_=(x$1: Nothing): Unit
+
+### indexOf
+def indexOf[B](elem: B, from: Int): Int
+
+### indexOf
+def indexOf[B](elem: B): Int
+
+### indexOfSlice
+def indexOfSlice[B](that: GenSeq[B], from: Int): Int
+
+### indexOfSlice
+def indexOfSlice[B](that: GenSeq[B]): Int
+
+### indexWhere
+def indexWhere(p: (A) => Boolean, from: Int): Int
+
+### indexWhere
+def indexWhere(p: (A) => Boolean): Int
+
+### indices
+def indices: Range
+
+### init
+def init: Repr
+
+### inits
+def inits: Iterator[Repr]
+
+### intersect
+def intersect[B](that: GenSeq[B]): Repr
+
+### isDefinedAt
+def isDefinedAt(idx: Int): Boolean
+
+### isEmpty
+override def isEmpty: Boolean
+
+### isTraversableAgain
+final def isTraversableAgain: Boolean
+
+### iterator
+def iterator: Iterator[T]
+
+### last
+def last: A
+
+### lastIndexOf
+def lastIndexOf[B](elem: B, end: Int): Int
+
+### lastIndexOf
+def lastIndexOf[B](elem: B): Int
+
+### lastIndexOfSlice
+def lastIndexOfSlice[B](that: GenSeq[B], end: Int): Int
+
+### lastIndexOfSlice
+def lastIndexOfSlice[B](that: GenSeq[B]): Int
+
+### lastIndexWhere
+def lastIndexWhere(p: (A) => Boolean, end: Int): Int
+
+### lastIndexWhere
+def lastIndexWhere(p: (A) => Boolean): Int
+
+### lastOption
+def lastOption: Option[A]
+
+### length
+override def length: Int
+
+### lengthCompare
+def lengthCompare(len: Int): Int
+
+### lift
+def lift: (A) => Option[B]
+
+### linkMethodInDoc
+def linkMethodInDoc(): Nothing
+method: [example.UserDocLinkingClass.linkMeFromUserDoc](../../example/UserDocLinkingClass.md#linkMeFromUserDoc)
+method:[example.level2.Documentation.apply](../../example/level2/Documentation.md#apply)
+class: [example.UserDocLinkingClass](../../example/UserDocLinkingClass.md)
+
+### linkingGraph
+def linkingGraph(g: Graph): Node
+
+### linkingToDocMethodInUserDoc
+def linkingToDocMethodInUserDoc: Nothing
+[example.level2.Documentation](../../../../example/level2.md#Documentation)
+[example.level2.Documentation$.valInsideDocObject](../../../../example/level2/Documentation$.md#valInsideDocObject)
+[example.level2.Documentation.abstractType](../../../../example/level2/Documentation.md#abstractType)
+
+### map
+def map[B, That](f: (A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### max
+def max[B](implicit cmp: Ordering[B]): A
+
+### maxBy
+def maxBy[B](f: (A) => B)(implicit cmp: Ordering[B]): A
+
+### methodsWithCallByName
+def methodsWithCallByName(x: => Int): Nothing
+
+### methodsWithDefault
+def methodsWithDefault(x: Int): Nothing
+
+### methodsWithImplicit
+def methodsWithImplicit(x: Int)(implicit imp: Int, notImp: String): Nothing
+
+### methodsWithParams
+def methodsWithParams(x: T, y: Int): List[Map[Int, T]]
+Test methods with params
+
+***return*** something is returned
+
+***y*** parameter 2
+
+***x*** parameter 1
+
+### min
+def min[B](implicit cmp: Ordering[B]): A
+
+### minBy
+def minBy[B](f: (A) => B)(implicit cmp: Ordering[B]): A
+
+### mkString
+def mkString: String
+
+### mkString
+def mkString(sep: String): String
+
+### mkString
+def mkString(start: String, sep: String, end: String): String
+
+### newBuilder
+protected def newBuilder: Builder[A, CC[A]]
+
+### nonEmpty
+def nonEmpty: Boolean
+
+### orElse
+def orElse[A1, B1](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
+
+### padTo
+def padTo[B, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### par
+def par: ParRepr
+
+### parCombiner
+protected override def parCombiner: Combiner[A, ParSeq[A]]
+
+### partition
+def partition(p: (A) => Boolean): (Repr, Repr)
+
+### patch
+def patch[B, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### permutations
+def permutations: Iterator[Repr]
+
+### prefixLength
+def prefixLength(p: (A) => Boolean): Int
+
+### product
+def product[B](implicit num: Numeric[B]): B
+
+### productArity
+def productArity: Int
+
+### productElement
+def productElement(n: Int): Any
+
+### productIterator
+def productIterator: Iterator[Any]
+
+### productPrefix
+def productPrefix: String
+
+### protectedMethod
+protected def protectedMethod: Nothing
+
+### reduce
+def reduce[A1](op: (A1, A1) => A1): A1
+
+### reduceLeft
+def reduceLeft[B](op: (B, A) => B): B
+
+### reduceLeftOption
+def reduceLeftOption[B](op: (B, A) => B): Option[B]
+
+### reduceOption
+def reduceOption[A1](op: (A1, A1) => A1): Option[A1]
+
+### reduceRight
+override def reduceRight[B](op: (A, B) => B): B
+
+### reduceRightOption
+def reduceRightOption[B](op: (A, B) => B): Option[B]
+
+### repr
+def repr: Repr
+
+### reverse
+def reverse: Repr
+
+### reverseIterator
+def reverseIterator: Iterator[A]
+
+### reverseMap
+def reverseMap[B, That](f: (A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### reversed
+protected def reversed: List[A]
+
+### runWith
+def runWith[U](action: (B) => U): (A) => Boolean
+
+### sameElements
+def sameElements[B](that: GenIterable[B]): Boolean
+
+### scan
+def scan[B, That](z: B)(op: (B, B) => B)(implicit cbf: CanBuildFrom[Repr, B, That]): That
+
+### scanLeft
+def scanLeft[B, That](z: B)(op: (B, A) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### scanRight
+@migration def scanRight[B, That](z: B)(op: (A, B) => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### segmentLength
+def segmentLength(p: (A) => Boolean, from: Int): Int
+
+### seq
+override def seq: Seq[A]
+
+### size
+override def size: Int
+
+### sizeHintIfCheap
+private[collection] def sizeHintIfCheap: Int
+
+### slice
+override def slice(from: Int, until: Int): Repr
+
+### sliceWithKnownBound
+private[scala] def sliceWithKnownBound(from: Int, until: Int): Repr
+
+### sliceWithKnownDelta
+private[scala] def sliceWithKnownDelta(from: Int, until: Int, delta: Int): Repr
+
+### sliding
+def sliding(size: Int, step: Int): Iterator[Repr]
+
+### sliding
+def sliding(size: Int): Iterator[Repr]
+
+### sortBy
+def sortBy[B](f: (A) => B)(implicit ord: Ordering[B]): Repr
+
+### sortWith
+def sortWith(lt: (A, A) => Boolean): Repr
+
+### sorted
+def sorted[B](implicit ord: Ordering[B]): Repr
+
+### span
+def span(p: (A) => Boolean): (Repr, Repr)
+
+### splitAt
+def splitAt(n: Int): (Repr, Repr)
+
+### startsWith
+def startsWith[B](that: GenSeq[B], offset: Int): Boolean
+
+### startsWith
+def startsWith[B](that: GenSeq[B]): Boolean
+
+### stringPrefix
+def stringPrefix: String
+
+### sum
+def sum[B](implicit num: Numeric[B]): B
+
+### tail
+override def tail: Repr
+
+### tails
+def tails: Iterator[Repr]
+
+### take
+override def take(n: Int): Repr
+
+### takeRight
+def takeRight(n: Int): Repr
+
+### takeWhile
+override def takeWhile(p: (A) => Boolean): Repr
+
+### thisCollection
+protected override def thisCollection: Seq[A]
+
+### to
+override def to[Col](implicit cbf: CanBuildFrom[Nothing, A, Col[A]]): Col[A]
+
+### toArray
+def toArray[B](implicit evidence$1: ClassTag[B]): Array[B]
+
+### toBuffer
+def toBuffer[B]: Buffer[B]
+
+### toCollection
+protected override def toCollection(repr: Repr): Seq[A]
+
+### toIndexedSeq
+def toIndexedSeq: IndexedSeq[A]
+
+### toIterable
+override def toIterable: Iterable[A]
+
+### toIterator
+@deprecatedOverriding override def toIterator: Iterator[A]
+
+### toList
+def toList: List[A]
+
+### toMap
+def toMap[T, U](implicit ev: <:<[A, (T, U)]): Map[T, U]
+
+### toSeq
+override def toSeq: Seq[A]
+
+### toSet
+def toSet[B]: Set[B]
+
+### toStream
+override def toStream: Stream[A]
+
+### toString
+override def toString(): String
+
+### toTraversable
+@deprecatedOverriding def toTraversable: Traversable[A]
+
+### toVector
+def toVector: Vector[A]
+
+### transpose
+@migration def transpose[B](implicit asTraversable: (A) => GenTraversableOnce[B]): CC[CC[B]]
+
+### union
+override def union[B, That](that: GenSeq[B])(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### unzip
+def unzip[A1, A2](implicit asPair: (A) => (A1, A2)): (CC[A1], CC[A2])
+
+### unzip3
+def unzip3[A1, A2, A3](implicit asTriple: (A) => (A1, A2, A3)): (CC[A1], CC[A2], CC[A3])
+
+### updated
+def updated[B, That](index: Int, elem: B)(implicit bf: CanBuildFrom[Repr, B, That]): That
+
+### useOfOutsideType
+def useOfOutsideType(): ReturnTypeClass[T]
+
+### useOfOutsideTypeInsideObject
+def useOfOutsideTypeInsideObject(): returnType
+
+### useOfSameLevelOutsideType
+def useOfSameLevelOutsideType(): SameLevelTypeLinking
+
+### view
+override def view(from: Int, until: Int): SeqView[A, Repr]
+
+### view
+override def view: AnyRef & SeqView[A, Repr]
+
+### withFilter
+def withFilter(p: (A) => Boolean): FilterMonadic[A, Repr]
+
+### zip
+def zip[A1, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That
+
+### zipAll
+def zipAll[B, A1, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Repr, (A1, B), That]): That
+
+### zipWithIndex
+def zipWithIndex[A1, That](implicit bf: CanBuildFrom[Repr, (A1, Int), That]): That
+
diff --git a/tastydoc/documentation/example/level2/level3/level4/level4.md b/tastydoc/documentation/example/level2/level3/level4/level4.md
new file mode 100644
index 000000000000..91d7d288487e
--- /dev/null
+++ b/tastydoc/documentation/example/level2/level3/level4/level4.md
@@ -0,0 +1,3 @@
+# Package level4
+## Members:
+sealed abstract class ClassLevel4
diff --git a/tastydoc/documentation/scala/*:$.md b/tastydoc/documentation/scala/*:$.md
new file mode 100644
index 000000000000..c41fe4f530b5
--- /dev/null
+++ b/tastydoc/documentation/scala/*:$.md
@@ -0,0 +1,10 @@
+scala
+# object *:
+
+## Companion class *:
+
+final object *: extends Serializable
+## Concrete Value Members:
+### unapply
+inline def unapply[H, T <: scala.Tuple](x: *:[H, T]): (H, T)
+
diff --git a/tastydoc/documentation/scala/*:.md b/tastydoc/documentation/scala/*:.md
new file mode 100644
index 000000000000..af6172a7d377
--- /dev/null
+++ b/tastydoc/documentation/scala/*:.md
@@ -0,0 +1,41 @@
+scala
+# class *:
+
+## Companion object *:
+
+sealed abstract class *:[H, T <: scala.Tuple] extends NonEmptyTuple
+## Annotations:
+@showAsInfix
+## Concrete Value Members:
+### *:
+inline def *:[H, This >: this.type <: scala.Tuple](x: H): *:[H, This]
+Return a new tuple by prepending the element to `this` tuple.
+This opteration is O(this.size)
+
+### ++
+inline def ++[This >: this.type <: scala.Tuple](that: Tuple): Concat[This, that]
+Return a new tuple by concatenating `this` tuple with `that` tuple.
+This opteration is O(this.size + that.size)
+
+### apply
+inline def apply[This >: this.type <: scala.NonEmptyTuple](n: Int): Elem[This, n]
+Get the i-th element of this tuple.
+Equivalent to productElement but with a precise return type.
+
+### head
+inline def head[This >: this.type <: scala.NonEmptyTuple]: Head[This]
+Get the head of this tuple
+
+### size
+inline def size[This >: this.type <: scala.Tuple]: Size[This]
+Return the size (or arity) of the tuple
+
+### tail
+inline def tail[This >: this.type <: scala.NonEmptyTuple]: Tail[This]
+Get the tail of this tuple.
+This opteration is O(this.size)
+
+### toArray
+inline def toArray: Array[Object]
+Create a copy this tuple as an Array
+
diff --git a/tastydoc/documentation/scala/Conversion.md b/tastydoc/documentation/scala/Conversion.md
new file mode 100644
index 000000000000..ab70bd3f0b8d
--- /dev/null
+++ b/tastydoc/documentation/scala/Conversion.md
@@ -0,0 +1,33 @@
+scala
+# class Conversion
+
+abstract class Conversion[T, U] extends (T) => U
+A class for implicit values that can serve as implicit conversions
+The implicit resolution algorithm will act as if there existed
+the additional implicit definition:
+ def $implicitConversion[T, U](x: T)(c: Conversion[T, U]): U = c(x)
+However, the presence of this definition would slow down implicit search since
+its outermost type matches any pair of types. Therefore, implicit search
+contains a special case in `Implicits#discardForView` which emulates the
+conversion in a more efficient way.
+Note that this is a SAM class - function literals are automatically converted
+to the `Conversion` values.
+Also note that in bootstrapped dotty, `Predef.<:<` should inherit from
+`Conversion`. This would cut the number of special cases in `discardForView`
+from two to one.
+
+## Annotations:
+@FunctionalInterface
+## Concrete Value Members:
+### andThen
+@unspecialized def andThen[A](g: (R) => A): (T1) => A
+
+### apply
+def apply(v1: T1): R
+
+### compose
+@unspecialized def compose[A](g: (A) => T1): (A) => R
+
+### toString
+override def toString(): String
+
diff --git a/tastydoc/documentation/scala/Enum.md b/tastydoc/documentation/scala/Enum.md
new file mode 100644
index 000000000000..28eff64832de
--- /dev/null
+++ b/tastydoc/documentation/scala/Enum.md
@@ -0,0 +1,14 @@
+scala
+# trait Enum
+
+trait Enum
+A base trait of all enum classes
+
+## Concrete Value Members:
+### $ordinal
+protected def $ordinal: Int
+
+### ordinal
+def ordinal: Int
+A number uniquely identifying a case of an enum
+
diff --git a/tastydoc/documentation/scala/Eql$.md b/tastydoc/documentation/scala/Eql$.md
new file mode 100644
index 000000000000..ee7b70bd0986
--- /dev/null
+++ b/tastydoc/documentation/scala/Eql$.md
@@ -0,0 +1,38 @@
+scala
+# object Eql
+
+## Companion trait Eql
+
+final object Eql extends Serializable with Sum
+Companion object containing a few universally known `Eql` instances.
+Eql instances involving primitive types or the Null type are handled directly in
+the compiler (see Implicits.synthesizedEq), so they are not included here.
+
+## Concrete Type Members:
+### derived
+final object derived
+A universal `Eql` instance.
+
+## Concrete Value Members:
+### eqlAny
+def eqlAny[L, R]: Eql[L, R]
+A fall-back instance to compare values of any types.
+Even though this method is not declared a delegate, the compiler will
+synthesize implicit arguments as solutions to `Eql[T, U]` queries if
+the rules of multiversal equality require it.
+
+### eqlNumber
+implicit def eqlNumber: Eql[Number, Number]
+
+### eqlProxy
+implicit def eqlProxy: Eql[Proxy, AnyRef]
+
+### eqlSeq
+implicit def eqlSeq[T, U](implicit eq: Eql[T, U]): Eql[GenSeq[T], GenSeq[U]]
+
+### eqlSet
+implicit def eqlSet[T, U](implicit eq: Eql[T, U]): Eql[Set[T], Set[U]]
+
+### eqlString
+implicit def eqlString: Eql[String, String]
+
diff --git a/tastydoc/documentation/scala/Eql$/derived$.md b/tastydoc/documentation/scala/Eql$/derived$.md
new file mode 100644
index 000000000000..9b78429aa4d2
--- /dev/null
+++ b/tastydoc/documentation/scala/Eql$/derived$.md
@@ -0,0 +1,6 @@
+scala.Eql$
+# object derived
+
+final object derived extends Eql[Any, Any] with Serializable
+A universal `Eql` instance.
+
diff --git a/tastydoc/documentation/scala/Eql.md b/tastydoc/documentation/scala/Eql.md
new file mode 100644
index 000000000000..c3f127d2d692
--- /dev/null
+++ b/tastydoc/documentation/scala/Eql.md
@@ -0,0 +1,10 @@
+scala
+# trait Eql
+
+## Companion object Eql
+
+sealed trait Eql[L, R]
+A marker trait indicating that values of type `L` can be compared to values of type `R`.
+
+## Annotations:
+@implicitNotFound
diff --git a/tastydoc/documentation/scala/FunctionXXL.md b/tastydoc/documentation/scala/FunctionXXL.md
new file mode 100644
index 000000000000..2158fafdee79
--- /dev/null
+++ b/tastydoc/documentation/scala/FunctionXXL.md
@@ -0,0 +1,13 @@
+scala
+# trait FunctionXXL
+
+trait FunctionXXL
+A function with all parameters grouped in an array.
+
+## Concrete Value Members:
+### apply
+def apply(xs: Array[Object]): Object
+
+### toString
+override def toString(): String
+
diff --git a/tastydoc/documentation/scala/IArray$package$.md b/tastydoc/documentation/scala/IArray$package$.md
new file mode 100644
index 000000000000..084760d32298
--- /dev/null
+++ b/tastydoc/documentation/scala/IArray$package$.md
@@ -0,0 +1,17 @@
+scala
+# object IArray$package
+
+final object IArray$package extends Serializable
+## Concrete Type Members:
+### IArray
+type IArray: [+T >: scala.Nothing <: scala.Any] => scala.Array[_ >: scala.Nothing <: +T]
+An immutable array. An `IArray[T]` has the same representation as an `Array[T]`,
+but it cannot be updated. Unlike regular arrays, immutable arrays are covariant.
+
+
+### IArray
+final object IArray
+### arrayOps
+final object arrayOps
+Defines extension methods for immutable arrays
+
diff --git a/tastydoc/documentation/scala/IArray$package$/IArray$.md b/tastydoc/documentation/scala/IArray$package$/IArray$.md
new file mode 100644
index 000000000000..765994724344
--- /dev/null
+++ b/tastydoc/documentation/scala/IArray$package$/IArray$.md
@@ -0,0 +1,222 @@
+scala.IArray$package$
+# object IArray
+
+final object IArray extends Serializable
+## Concrete Value Members:
+### apply
+def apply(x: Unit, xs: Seq[Unit]): IArray[Unit]
+
+### apply
+def apply(x: Double, xs: Seq[Double]): IArray[Double]
+
+### apply
+def apply(x: Float, xs: Seq[Float]): IArray[Float]
+
+### apply
+def apply(x: Long, xs: Seq[Long]): IArray[Long]
+
+### apply
+def apply(x: Int, xs: Seq[Int]): IArray[Int]
+
+### apply
+def apply(x: Char, xs: Seq[Char]): IArray[Char]
+
+### apply
+def apply(x: Short, xs: Seq[Short]): IArray[Short]
+
+### apply
+def apply(x: Byte, xs: Seq[Byte]): IArray[Byte]
+
+### apply
+def apply(x: Boolean, xs: Seq[Boolean]): IArray[Boolean]
+
+### apply
+def apply[T](xs: Seq[T])(implicit evidence$4: ClassTag[T]): IArray[T]
+An immutable array with given elements.
+
+### concat
+def concat[T](xss: Seq[IArray[T]])(implicit evidence$5: ClassTag[T]): IArray[T]
+Concatenates all arrays into a single immutable array.
+
+***return*** the array created from concatenating `xss`
+
+***xss*** the given immutable arrays
+
+### empty
+def empty[T](implicit evidence$3: ClassTag[T]): IArray[T]
+An immutable array of length 0.
+
+### fill
+def fill[T](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(elem: => T)(implicit evidence$10: ClassTag[T]): IArray[IArray[IArray[IArray[IArray[T]]]]]
+Returns a five-dimensional immutable array that contains the results of some element computation a number
+of times. Each element is determined by a separate computation.
+
+***n2*** the number of elements in the 2nd dimension
+
+***n5*** the number of elements in the 5th dimension
+
+***n1*** the number of elements in the 1st dimension
+
+***n4*** the number of elements in the 4th dimension
+
+***elem*** the element computation
+
+***n3*** the number of elements in the 3nd dimension
+
+### fill
+def fill[T](n1: Int, n2: Int, n3: Int, n4: Int)(elem: => T)(implicit evidence$9: ClassTag[T]): IArray[IArray[IArray[IArray[T]]]]
+Returns a four-dimensional immutable array that contains the results of some element computation a number
+of times. Each element is determined by a separate computation.
+
+***n2*** the number of elements in the 2nd dimension
+
+***n1*** the number of elements in the 1st dimension
+
+***n4*** the number of elements in the 4th dimension
+
+***elem*** the element computation
+
+***n3*** the number of elements in the 3nd dimension
+
+### fill
+def fill[T](n1: Int, n2: Int, n3: Int)(elem: => T)(implicit evidence$8: ClassTag[T]): IArray[IArray[IArray[T]]]
+Returns a three-dimensional immutable array that contains the results of some element computation a number
+of times. Each element is determined by a separate computation.
+
+***n2*** the number of elements in the 2nd dimension
+
+***n3*** the number of elements in the 3nd dimension
+
+***n1*** the number of elements in the 1st dimension
+
+***elem*** the element computation
+
+### fill
+def fill[T](n1: Int, n2: Int)(elem: => T)(implicit evidence$7: ClassTag[T]): IArray[IArray[T]]
+Returns a two-dimensional immutable array that contains the results of some element computation a number
+of times. Each element is determined by a separate computation.
+
+***n2*** the number of elements in the 2nd dimension
+
+***n1*** the number of elements in the 1st dimension
+
+***elem*** the element computation
+
+### fill
+def fill[T](n: Int)(elem: => T)(implicit evidence$6: ClassTag[T]): IArray[T]
+Returns an immutable array that contains the results of some element computation a number
+of times. Each element is determined by a separate computation.
+
+***n*** the number of elements in the array
+
+***elem*** the element computation
+
+### iterate
+def iterate[T](start: T, len: Int)(f: (T) => T)(implicit evidence$16: ClassTag[T]): IArray[T]
+Returns an immutable array containing repeated applications of a function to a start value.
+
+***return*** the immutable array returning `len` values in the sequence `start, f(start), f(f(start)), ...`
+
+***f*** the function that is repeatedly applied
+
+***len*** the number of elements returned by the array
+
+***start*** the start value of the array
+
+### range
+def range(start: Int, end: Int, step: Int): IArray[Int]
+Returns an immutable array containing equally spaced values in some integer interval.
+
+***return*** the immutable array with values in `start, start + step, ...` up to, but excluding `end`
+
+***step*** the increment value of the array (may not be zero)
+
+***end*** the end value of the array, exclusive (in other words, this is the first value **not** returned)
+
+***start*** the start value of the array
+
+### range
+def range(start: Int, end: Int): IArray[Int]
+Returns an immutable array containing a sequence of increasing integers in a range.
+
+***return*** the immutable array with values in range `start, start + 1, ..., end - 1`
+up to, but excluding, `end`.
+
+***end*** the end value of the array, exclusive (in other words, this is the first value **not** returned)
+
+***start*** the start value of the array
+
+### tabulate
+def tabulate[T](n1: Int, n2: Int, n3: Int, n4: Int, n5: Int)(f: (Int, Int, Int, Int, Int) => T)(implicit evidence$15: ClassTag[T]): IArray[IArray[IArray[IArray[IArray[T]]]]]
+Returns a five-dimensional immutable array containing values of a given function
+over ranges of integer values starting from `0`.
+
+***n2*** the number of elements in the 2nd dimension
+
+***n5*** the number of elements in the 5th dimension
+
+***n1*** the number of elements in the 1st dimension
+
+***f*** The function computing element values
+
+***n4*** the number of elements in the 4th dimension
+
+***n3*** the number of elements in the 3rd dimension
+
+### tabulate
+def tabulate[T](n1: Int, n2: Int, n3: Int, n4: Int)(f: (Int, Int, Int, Int) => T)(implicit evidence$14: ClassTag[T]): IArray[IArray[IArray[IArray[T]]]]
+Returns a four-dimensional immutable array containing values of a given function
+over ranges of integer values starting from `0`.
+
+***n2*** the number of elements in the 2nd dimension
+
+***n1*** the number of elements in the 1st dimension
+
+***f*** The function computing element values
+
+***n4*** the number of elements in the 4th dimension
+
+***n3*** the number of elements in the 3rd dimension
+
+### tabulate
+def tabulate[T](n1: Int, n2: Int, n3: Int)(f: (Int, Int, Int) => T)(implicit evidence$13: ClassTag[T]): IArray[IArray[IArray[T]]]
+Returns a three-dimensional immutable array containing values of a given function
+over ranges of integer values starting from `0`.
+
+***n2*** the number of elements in the 2nd dimension
+
+***f*** The function computing element values
+
+***n3*** the number of elements in the 3rd dimension
+
+***n1*** the number of elements in the 1st dimension
+
+### tabulate
+def tabulate[T](n1: Int, n2: Int)(f: (Int, Int) => T)(implicit evidence$12: ClassTag[T]): IArray[IArray[T]]
+Returns a two-dimensional immutable array containing values of a given function
+over ranges of integer values starting from `0`.
+
+***n2*** the number of elements in the 2nd dimension
+
+***f*** The function computing element values
+
+***n1*** the number of elements in the 1st dimension
+
+### tabulate
+def tabulate[T](n: Int)(f: (Int) => T)(implicit evidence$11: ClassTag[T]): IArray[T]
+Returns an immutable array containing values of a given function over a range of integer
+values starting from 0.
+
+***n*** The number of elements in the array
+
+***f*** The function computing element values
+
+### unapplySeq
+def unapplySeq[T](x: IArray[T]): Option[IndexedSeq[T]]
+Returns a decomposition of the array into a sequence. This supports
+a pattern match like `{ case IArray(x,y,z) => println('3 elements')}`.
+
+***return*** sequence wrapped in a scala.Some, if `x` is a Seq, otherwise `None`
+
+***x*** the selector value
+
diff --git a/tastydoc/documentation/scala/IArray$package$/arrayOps$.md b/tastydoc/documentation/scala/IArray$package$/arrayOps$.md
new file mode 100644
index 000000000000..648f5a453f15
--- /dev/null
+++ b/tastydoc/documentation/scala/IArray$package$/arrayOps$.md
@@ -0,0 +1,23 @@
+scala.IArray$package$
+# object arrayOps
+
+final object arrayOps extends Serializable
+Defines extension methods for immutable arrays
+
+## Concrete Value Members:
+### apply
+inline def apply[T](arr: IArray[T])(n: Int): T
+The selection operation on an immutable array.
+
+***return*** the element of the array at the given index
+
+***n*** the index of the element to select
+
+***arr*** the immutable array
+
+### length
+inline def length[T](arr: IArray[T]): Int
+The number of elements in an immutable array
+
+***arr*** the immutable array
+
diff --git a/tastydoc/documentation/scala/NonEmptyTuple.md b/tastydoc/documentation/scala/NonEmptyTuple.md
new file mode 100644
index 000000000000..898905234aa5
--- /dev/null
+++ b/tastydoc/documentation/scala/NonEmptyTuple.md
@@ -0,0 +1,41 @@
+scala
+# trait NonEmptyTuple
+
+sealed trait NonEmptyTuple extends Tuple
+Tuple of arbitrary non-zero arity
+
+## Known subclasses:
+*:
+## Concrete Value Members:
+### *:
+inline def *:[H, This >: this.type <: scala.Tuple](x: H): *:[H, This]
+Return a new tuple by prepending the element to `this` tuple.
+This opteration is O(this.size)
+
+### ++
+inline def ++[This >: this.type <: scala.Tuple](that: Tuple): Concat[This, that]
+Return a new tuple by concatenating `this` tuple with `that` tuple.
+This opteration is O(this.size + that.size)
+
+### apply
+inline def apply[This >: this.type <: scala.NonEmptyTuple](n: Int): Elem[This, n]
+Get the i-th element of this tuple.
+Equivalent to productElement but with a precise return type.
+
+### head
+inline def head[This >: this.type <: scala.NonEmptyTuple]: Head[This]
+Get the head of this tuple
+
+### size
+inline def size[This >: this.type <: scala.Tuple]: Size[This]
+Return the size (or arity) of the tuple
+
+### tail
+inline def tail[This >: this.type <: scala.NonEmptyTuple]: Tail[This]
+Get the tail of this tuple.
+This opteration is O(this.size)
+
+### toArray
+inline def toArray: Array[Object]
+Create a copy this tuple as an Array
+
diff --git a/tastydoc/documentation/scala/PolyFunction.md b/tastydoc/documentation/scala/PolyFunction.md
new file mode 100644
index 000000000000..fd998bc28cb8
--- /dev/null
+++ b/tastydoc/documentation/scala/PolyFunction.md
@@ -0,0 +1,10 @@
+scala
+# trait PolyFunction
+
+trait PolyFunction
+Marker trait for polymorphic function types.
+This is the only trait that can be refined with a polymorphic method,
+as long as that method is called `apply`, e.g.:
+ PolyFunction { def apply[T_1, ..., T_M](x_1: P_1, ..., x_N: P_N): R }
+This type will be erased to FunctionN.
+
diff --git a/tastydoc/documentation/scala/Product0$.md b/tastydoc/documentation/scala/Product0$.md
new file mode 100644
index 000000000000..f31c0c10d09c
--- /dev/null
+++ b/tastydoc/documentation/scala/Product0$.md
@@ -0,0 +1,12 @@
+scala
+# object Product0
+
+## Companion trait Product0
+
+final object Product0 extends Serializable
+A class for Product0 which was missing from the scala distribution.
+
+## Concrete Value Members:
+### unapply
+def unapply(x: Product0): Option[Product0]
+
diff --git a/tastydoc/documentation/scala/Product0.md b/tastydoc/documentation/scala/Product0.md
new file mode 100644
index 000000000000..6298c100b56e
--- /dev/null
+++ b/tastydoc/documentation/scala/Product0.md
@@ -0,0 +1,22 @@
+scala
+# trait Product0
+
+## Companion object Product0
+
+trait Product0 extends Any with Product
+## Concrete Value Members:
+### canEqual
+def canEqual(that: Any): Boolean
+
+### productArity
+override def productArity: Int
+
+### productElement
+@throws[IndexOutOfBoundsException] override def productElement(n: Int): Any
+
+### productIterator
+def productIterator: Iterator[Any]
+
+### productPrefix
+def productPrefix: String
+
diff --git a/tastydoc/documentation/scala/Selectable.md b/tastydoc/documentation/scala/Selectable.md
new file mode 100644
index 000000000000..fe777aeb2446
--- /dev/null
+++ b/tastydoc/documentation/scala/Selectable.md
@@ -0,0 +1,13 @@
+scala
+# trait Selectable
+
+trait Selectable extends Any
+## Known subclasses:
+Selectable
+## Concrete Value Members:
+### applyDynamic
+def applyDynamic(name: String, paramClasses: Seq[ClassTag[Nothing <: Any]])(args: Seq[Any]): Any
+
+### selectDynamic
+def selectDynamic(name: String): Any
+
diff --git a/tastydoc/documentation/scala/Tuple$.md b/tastydoc/documentation/scala/Tuple$.md
new file mode 100644
index 000000000000..1aea7765f0a7
--- /dev/null
+++ b/tastydoc/documentation/scala/Tuple$.md
@@ -0,0 +1,64 @@
+scala
+# object Tuple
+
+## Companion trait Tuple
+
+final object Tuple extends Serializable
+## Concrete Type Members:
+### Concat
+type Concat: [X >: scala.Nothing <: scala.Tuple, +Y >: scala.Nothing <: scala.Tuple] => X match {
+ scala.internal.MatchCase[scala.Unit, +Y]
+ [x1 >: scala.Nothing <: scala.Any, xs1 >: scala.Nothing <: scala.Tuple] => scala.internal.MatchCase[scala.*:[x1, xs1], scala.*:[x1, scala.Tuple.Concat[xs1, +Y]]]
+}
+Type of the concatenation of two tuples
+
+
+### Elem
+type Elem: [X >: scala.Nothing <: scala.Tuple, N >: scala.Nothing <: scala.Int] => X match {
+ [x >: scala.Nothing <: scala.Any, xs >: scala.Nothing <: scala.Tuple] => scala.internal.MatchCase[scala.*:[x, xs], N match {
+ scala.internal.MatchCase[0, x]
+ [n1 >: scala.Nothing <: scala.Int] => scala.internal.MatchCase[scala.compiletime.S[n1], scala.Tuple.Elem[xs, n1]]
+ }]
+}
+Type of the element a position N in the tuple X
+
+
+### Head
+type Head: [X >: scala.Nothing <: scala.NonEmptyTuple] => X match {
+ [x >: scala.Nothing <: scala.Any, _ >: scala.Nothing <: scala.Tuple] => scala.internal.MatchCase[scala.*:[x, _], x]
+}
+Type of the head of a tuple
+
+
+### Map
+type Map: [Tup >: scala.Nothing <: scala.Tuple, F >: scala.Nothing <: [_$1 >: scala.Nothing <: scala.Any] => scala.Any] => Tup match {
+ scala.internal.MatchCase[scala.Unit, scala.Unit]
+ [h >: scala.Nothing <: scala.Any, t >: scala.Nothing <: scala.Tuple] => scala.internal.MatchCase[scala.*:[h, t], scala.*:[F[h], scala.Tuple.Map[t, F]]]
+}
+Converts a tuple `(T1, ..., Tn)` to `(F[T1], ..., F[Tn])`
+
+
+### Size
+type Size: [X >: scala.Nothing <: scala.Tuple] => X match {
+ scala.internal.MatchCase[scala.Unit, 0]
+ [x >: scala.Nothing <: scala.Any, xs >: scala.Nothing <: scala.Tuple] => scala.internal.MatchCase[scala.*:[x, xs], scala.compiletime.S[scala.Tuple.Size[xs]]]
+}
+Literal constant Int size of a tuple
+
+
+### Tail
+type Tail: [X >: scala.Nothing <: scala.NonEmptyTuple] => X match {
+ [_ >: scala.Nothing <: scala.Any, xs >: scala.Nothing <: scala.Tuple] => scala.internal.MatchCase[scala.*:[_, xs], xs]
+}
+Type of the tail of a tuple
+
+
+## Concrete Value Members:
+### fromArray
+def fromArray[T](xs: Array[T]): Tuple
+Convert an array into a tuple of unknown arity and types
+
+### fromProduct
+def fromProduct(product: Product): Tuple
+Convert a Product into a tuple of unknown arity and types
+
diff --git a/tastydoc/documentation/scala/Tuple.md b/tastydoc/documentation/scala/Tuple.md
new file mode 100644
index 000000000000..9b4bccd57f29
--- /dev/null
+++ b/tastydoc/documentation/scala/Tuple.md
@@ -0,0 +1,29 @@
+scala
+# trait Tuple
+
+## Companion object Tuple
+
+sealed trait Tuple extends Any
+Tuple of arbitrary arity
+
+## Known subclasses:
+NonEmptyTuple
+## Concrete Value Members:
+### *:
+inline def *:[H, This >: this.type <: scala.Tuple](x: H): *:[H, This]
+Return a new tuple by prepending the element to `this` tuple.
+This opteration is O(this.size)
+
+### ++
+inline def ++[This >: this.type <: scala.Tuple](that: Tuple): Concat[This, that]
+Return a new tuple by concatenating `this` tuple with `that` tuple.
+This opteration is O(this.size + that.size)
+
+### size
+inline def size[This >: this.type <: scala.Tuple]: Size[This]
+Return the size (or arity) of the tuple
+
+### toArray
+inline def toArray: Array[Object]
+Create a copy this tuple as an Array
+
diff --git a/tastydoc/documentation/scala/TupleXXL$.md b/tastydoc/documentation/scala/TupleXXL$.md
new file mode 100644
index 000000000000..1cb8bea1e540
--- /dev/null
+++ b/tastydoc/documentation/scala/TupleXXL$.md
@@ -0,0 +1,19 @@
+scala
+# object TupleXXL
+
+## Companion class TupleXXL
+
+final object TupleXXL extends Serializable
+## Concrete Value Members:
+### apply
+def apply(elems: Seq[Any]): TupleXXL
+
+### apply
+def apply(elems: Array[Object]): TupleXXL
+
+### fromIterator
+def fromIterator(elems: Iterator[Any]): TupleXXL
+
+### unapplySeq
+def unapplySeq(x: TupleXXL): Option[Seq[Any]]
+
diff --git a/tastydoc/documentation/scala/TupleXXL.md b/tastydoc/documentation/scala/TupleXXL.md
new file mode 100644
index 000000000000..f446fce73bad
--- /dev/null
+++ b/tastydoc/documentation/scala/TupleXXL.md
@@ -0,0 +1,43 @@
+scala
+# class TupleXXL
+
+## Companion object TupleXXL
+
+final class TupleXXL extends Product
+## Constructors:
+TupleXXL(es: Array[Object])
+
+## Concrete Value Members:
+### canEqual
+override def canEqual(that: Any): Boolean
+
+### elems
+def elems: Array[Object]
+
+### equals
+override def equals(that: Any): Boolean
+
+### hashCode
+override def hashCode: Int
+
+### productArity
+def productArity: Int
+
+### productElement
+def productElement(n: Int): Any
+
+### productIterator
+def productIterator: Iterator[Any]
+
+### productPrefix
+def productPrefix: String
+
+### tailXXL
+def tailXXL: TupleXXL
+
+### toArray
+def toArray: Array[Object]
+
+### toString
+override def toString: String
+
diff --git a/tastydoc/documentation/scala/TupledFunction.md b/tastydoc/documentation/scala/TupledFunction.md
new file mode 100644
index 000000000000..94cf2e66e047
--- /dev/null
+++ b/tastydoc/documentation/scala/TupledFunction.md
@@ -0,0 +1,19 @@
+scala
+# trait TupledFunction
+
+sealed trait TupledFunction[F, G]
+Type class relating a `FunctionN[..., R]` with an equivalent tupled function `Function1[TupleN[...], R]`
+
+***F*** a function type
+
+***G*** a tupled function type (function of arity 1 receiving a tuple as argument)
+
+## Annotations:
+@implicitNotFound
+## Concrete Value Members:
+### tupled
+def tupled(f: F): G
+
+### untupled
+def untupled(g: G): F
+
diff --git a/tastydoc/documentation/scala/ValueOf$.md b/tastydoc/documentation/scala/ValueOf$.md
new file mode 100644
index 000000000000..2e8eccac6ec8
--- /dev/null
+++ b/tastydoc/documentation/scala/ValueOf$.md
@@ -0,0 +1,39 @@
+scala
+# object ValueOf
+
+## Companion class ValueOf
+
+final object ValueOf extends Serializable
+`ValueOf[T]` provides the unique value of the type `T` where `T` is a type which has a
+single inhabitant. Eligible types are singleton types of the form `stablePath.type`,
+Unit and singleton types corresponding to value literals.
+Instances of `ValueOf[T]` are provided implicitly for all eligible types. Typically
+an instance would be required where a runtime value corresponding to a type level
+computation is needed.
+For example, we might define a type `Residue[M <: Int]` corresponding to the group of
+integers modulo `M`. We could then mandate that residues can be summed only when they
+are parameterized by the same modulus,
+```scala
+case class Residue[M <: Int](n: Int) extends AnyVal {
+ def +(rhs: Residue[M])(implicit m: ValueOf[M]): Residue[M] =
+ Residue((this.n + rhs.n) % valueOf[M])
+}
+
+val fiveModTen = Residue[10](5)
+val nineModTen = Residue[10](9)
+
+fiveModTen + nineModTen // OK == Residue[10](4)
+
+val fourModEleven = Residue[11](4)
+
+fiveModTen + fourModEleven // compiler error: type mismatch;
+ // found : Residue[11]
+ // required: Residue[10]
+```
+Notice that here the modulus is encoded in the type of the values and so does not
+incur any additional per-value storage cost. When a runtime value of the modulus
+is required in the implementation of `+` it is provided at the call site via the
+implicit argument `m` of type `ValueOf[M]`.
+
+## Annotations:
+@implicitNotFound
diff --git a/tastydoc/documentation/scala/ValueOf.md b/tastydoc/documentation/scala/ValueOf.md
new file mode 100644
index 000000000000..4f76d959b8af
--- /dev/null
+++ b/tastydoc/documentation/scala/ValueOf.md
@@ -0,0 +1,46 @@
+scala
+# class ValueOf
+
+## Companion object ValueOf
+
+final class ValueOf[T] extends AnyVal
+`ValueOf[T]` provides the unique value of the type `T` where `T` is a type which has a
+single inhabitant. Eligible types are singleton types of the form `stablePath.type`,
+Unit and singleton types corresponding to value literals.
+Instances of `ValueOf[T]` are provided implicitly for all eligible types. Typically
+an instance would be required where a runtime value corresponding to a type level
+computation is needed.
+For example, we might define a type `Residue[M <: Int]` corresponding to the group of
+integers modulo `M`. We could then mandate that residues can be summed only when they
+are parameterized by the same modulus,
+```scala
+case class Residue[M <: Int](n: Int) extends AnyVal {
+ def +(rhs: Residue[M])(implicit m: ValueOf[M]): Residue[M] =
+ Residue((this.n + rhs.n) % valueOf[M])
+}
+
+val fiveModTen = Residue[10](5)
+val nineModTen = Residue[10](9)
+
+fiveModTen + nineModTen // OK == Residue[10](4)
+
+val fourModEleven = Residue[11](4)
+
+fiveModTen + fourModEleven // compiler error: type mismatch;
+ // found : Residue[11]
+ // required: Residue[10]
+```
+Notice that here the modulus is encoded in the type of the values and so does not
+incur any additional per-value storage cost. When a runtime value of the modulus
+is required in the implementation of `+` it is provided at the call site via the
+implicit argument `m` of type `ValueOf[M]`.
+
+## Annotations:
+@implicitNotFound
+## Constructors:
+ValueOf(value: T)
+
+## Concrete Value Members:
+### value
+val value: T
+
diff --git a/tastydoc/documentation/scala/annotation/RefiningAnnotation.md b/tastydoc/documentation/scala/annotation/RefiningAnnotation.md
new file mode 100644
index 000000000000..a08dbb39383f
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/RefiningAnnotation.md
@@ -0,0 +1,8 @@
+scala.annotation
+# trait RefiningAnnotation
+
+trait RefiningAnnotation extends Annotation with StaticAnnotation
+A base trait for annotations that yield proper subtypes of the types they annotate.
+Refining annotations are more "sticky" than normal ones. They are conceptually kept
+around when normal refinements would also not be stripped away.
+
diff --git a/tastydoc/documentation/scala/annotation/alpha.md b/tastydoc/documentation/scala/annotation/alpha.md
new file mode 100644
index 000000000000..de92695540f4
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/alpha.md
@@ -0,0 +1,13 @@
+scala.annotation
+# class alpha
+
+final class alpha extends Annotation with StaticAnnotation
+An annotation that defines an external name for a definition.
+If an `alpha(extname)` annotation is given for a method or some other
+definition, its implementation will use the name `extname` instead of
+the regular name. An `alpha` annotation is mandatory for definitions
+with symbolic names.
+
+## Constructors:
+alpha(externalName: String)
+
diff --git a/tastydoc/documentation/scala/annotation/annotation.md b/tastydoc/documentation/scala/annotation/annotation.md
new file mode 100644
index 000000000000..37230080df40
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/annotation.md
@@ -0,0 +1,33 @@
+# Package annotation
+## Members:
+@setter @param @beanSetter @beanGetter @getter @field final class static
+trait RefiningAnnotation
+A base trait for annotations that yield proper subtypes of the types they annotate.
+Refining annotations are more "sticky" than normal ones. They are conceptually kept
+around when normal refinements would also not be stripped away.
+
+final class threadUnsafe
+This annotation can only be used on a field which defines a lazy val.
+When this annotation is used, the initialization of the lazy val will use a
+faster mechanism which is not thread-safe.
+
+final class alpha
+An annotation that defines an external name for a definition.
+If an `alpha(extname)` annotation is given for a method or some other
+definition, its implementation will use the name `extname` instead of
+the regular name. An `alpha` annotation is mandatory for definitions
+with symbolic names.
+
+final class infix
+A method annotation that suggests that the annotated method should
+be used as an infix operator. Infix operations with alphanumeric
+operator names require the operator to be annotated with `@infix`.
+
+@param class constructorOnly
+An annotation that goes on parameters of classes or traits. It asserts
+that the parameter is used only for initialization and is not kept in
+the class as a field. Violations of this assertion are flagged as
+compile errors. The annotation is particularly useful for implicit
+parameters since for these a textual scan is not sufficient to know
+where they are used.
+
diff --git a/tastydoc/documentation/scala/annotation/constructorOnly.md b/tastydoc/documentation/scala/annotation/constructorOnly.md
new file mode 100644
index 000000000000..1fb1fae3202f
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/constructorOnly.md
@@ -0,0 +1,13 @@
+scala.annotation
+# class constructorOnly
+
+class constructorOnly extends Annotation with StaticAnnotation
+An annotation that goes on parameters of classes or traits. It asserts
+that the parameter is used only for initialization and is not kept in
+the class as a field. Violations of this assertion are flagged as
+compile errors. The annotation is particularly useful for implicit
+parameters since for these a textual scan is not sufficient to know
+where they are used.
+
+## Annotations:
+@param
diff --git a/tastydoc/documentation/scala/annotation/infix.md b/tastydoc/documentation/scala/annotation/infix.md
new file mode 100644
index 000000000000..863f8dc56164
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/infix.md
@@ -0,0 +1,8 @@
+scala.annotation
+# class infix
+
+final class infix extends Annotation with StaticAnnotation
+A method annotation that suggests that the annotated method should
+be used as an infix operator. Infix operations with alphanumeric
+operator names require the operator to be annotated with `@infix`.
+
diff --git a/tastydoc/documentation/scala/annotation/internal/Alias.md b/tastydoc/documentation/scala/annotation/internal/Alias.md
new file mode 100644
index 000000000000..099928a1a6dc
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/internal/Alias.md
@@ -0,0 +1,11 @@
+scala.annotation.internal
+# class Alias
+
+class Alias extends Annotation
+An annotation to record a Scala2 pickled alias.
+
+***aliased*** A TermRef pointing to the aliased field.
+
+## Constructors:
+Alias(aliased: Any)
+
diff --git a/tastydoc/documentation/scala/annotation/internal/AnnotationDefault.md b/tastydoc/documentation/scala/annotation/internal/AnnotationDefault.md
new file mode 100644
index 000000000000..508dd8d705b1
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/internal/AnnotationDefault.md
@@ -0,0 +1,6 @@
+scala.annotation.internal
+# class AnnotationDefault
+
+class AnnotationDefault extends Annotation
+An annotation to tag Java annotation default values
+
diff --git a/tastydoc/documentation/scala/annotation/internal/Body.md b/tastydoc/documentation/scala/annotation/internal/Body.md
new file mode 100644
index 000000000000..5d3a6d33cf3c
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/internal/Body.md
@@ -0,0 +1,7 @@
+scala.annotation.internal
+# class Body
+
+final class Body extends Annotation
+The class associated with a `BodyAnnotation`, which indicates
+an inline method's right hand side
+
diff --git a/tastydoc/documentation/scala/annotation/internal/Child.md b/tastydoc/documentation/scala/annotation/internal/Child.md
new file mode 100644
index 000000000000..1f495f3bfc46
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/internal/Child.md
@@ -0,0 +1,17 @@
+scala.annotation.internal
+# class Child
+
+class Child[T] extends Annotation
+An annotation to indicate a child class or object of the annotated class.
+E.g. if we have
+ sealed class A
+ case class B() extends A
+ case class C() extends A
+Then the class symbol `A` would carry the annotations
+`@Child[Cref]`, @Child[Bref] where `Bref`, `Cref` are TypeRefs
+referring to the class symbols of `B` and `C`.
+Child annotations always appear in reverse order of textual occurrence.
+I.e. in the example above, it is guaranteed that the child annotation for `C`
+appears before the one for `B`.
+TODO: This should be `Child[T <: AnyKind]`
+
diff --git a/tastydoc/documentation/scala/annotation/internal/InlineParam.md b/tastydoc/documentation/scala/annotation/internal/InlineParam.md
new file mode 100644
index 000000000000..fe188b1d105c
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/internal/InlineParam.md
@@ -0,0 +1,6 @@
+scala.annotation.internal
+# class InlineParam
+
+final class InlineParam extends Annotation
+An annotation produced by Namer to indicate an inline parameter
+
diff --git a/tastydoc/documentation/scala/annotation/internal/Repeated.md b/tastydoc/documentation/scala/annotation/internal/Repeated.md
new file mode 100644
index 000000000000..ff225f7d7308
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/internal/Repeated.md
@@ -0,0 +1,8 @@
+scala.annotation.internal
+# class Repeated
+
+final class Repeated extends Annotation
+An annotation produced by desugaring to indicate that a
+sequence is a repeated parameter. I.e.
+ T* is expanded by Desugar to Seq[T] @Repeated
+
diff --git a/tastydoc/documentation/scala/annotation/internal/SourceFile.md b/tastydoc/documentation/scala/annotation/internal/SourceFile.md
new file mode 100644
index 000000000000..8651d173fa7a
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/internal/SourceFile.md
@@ -0,0 +1,11 @@
+scala.annotation.internal
+# class SourceFile
+
+class SourceFile extends Annotation
+An annotation to record a Scala2 pickled alias.
+
+***aliased*** A TermRef pointing to the aliased field.
+
+## Constructors:
+SourceFile(path: String)
+
diff --git a/tastydoc/documentation/scala/annotation/internal/WithBounds.md b/tastydoc/documentation/scala/annotation/internal/WithBounds.md
new file mode 100644
index 000000000000..140cad2f66e9
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/internal/WithBounds.md
@@ -0,0 +1,7 @@
+scala.annotation.internal
+# class WithBounds
+
+class WithBounds[Lo <: scala.AnyKind, Hi <: scala.AnyKind] extends Annotation
+An annotation to indicate a pair of type bounds that comes with a type.
+Used to indicate optional bounds of an opaque type
+
diff --git a/tastydoc/documentation/scala/annotation/internal/internal.md b/tastydoc/documentation/scala/annotation/internal/internal.md
new file mode 100644
index 000000000000..aa82cad78349
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/internal/internal.md
@@ -0,0 +1,55 @@
+# Package internal
+## Members:
+final class Body
+The class associated with a `BodyAnnotation`, which indicates
+an inline method's right hand side
+
+class Alias
+An annotation to record a Scala2 pickled alias.
+
+***aliased*** A TermRef pointing to the aliased field.
+
+class sharable
+An annotation indicating to `-Ycheck:reentrant` that a class or val can be safely shared.
+
+***see*** scala.annotation.internal.unshared
+
+class unshared
+An annotation indicating to `-Ycheck:reentrant` that an object will not be accessed from multiple threads.
+
+***see*** scala.annotation.internal.sharable
+
+final class InlineParam
+An annotation produced by Namer to indicate an inline parameter
+
+class Child
+An annotation to indicate a child class or object of the annotated class.
+E.g. if we have
+ sealed class A
+ case class B() extends A
+ case class C() extends A
+Then the class symbol `A` would carry the annotations
+`@Child[Cref]`, @Child[Bref] where `Bref`, `Cref` are TypeRefs
+referring to the class symbols of `B` and `C`.
+Child annotations always appear in reverse order of textual occurrence.
+I.e. in the example above, it is guaranteed that the child annotation for `C`
+appears before the one for `B`.
+TODO: This should be `Child[T <: AnyKind]`
+
+class AnnotationDefault
+An annotation to tag Java annotation default values
+
+class SourceFile
+An annotation to record a Scala2 pickled alias.
+
+***aliased*** A TermRef pointing to the aliased field.
+
+class WithBounds
+An annotation to indicate a pair of type bounds that comes with a type.
+Used to indicate optional bounds of an opaque type
+
+final class Repeated
+An annotation produced by desugaring to indicate that a
+sequence is a repeated parameter. I.e.
+ T* is expanded by Desugar to Seq[T] @Repeated
+
diff --git a/tastydoc/documentation/scala/annotation/internal/sharable.md b/tastydoc/documentation/scala/annotation/internal/sharable.md
new file mode 100644
index 000000000000..09c16e236eef
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/internal/sharable.md
@@ -0,0 +1,8 @@
+scala.annotation.internal
+# class sharable
+
+class sharable extends Annotation
+An annotation indicating to `-Ycheck:reentrant` that a class or val can be safely shared.
+
+***see*** scala.annotation.internal.unshared
+
diff --git a/tastydoc/documentation/scala/annotation/internal/unshared.md b/tastydoc/documentation/scala/annotation/internal/unshared.md
new file mode 100644
index 000000000000..d1882a22f150
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/internal/unshared.md
@@ -0,0 +1,8 @@
+scala.annotation.internal
+# class unshared
+
+class unshared extends Annotation
+An annotation indicating to `-Ycheck:reentrant` that an object will not be accessed from multiple threads.
+
+***see*** scala.annotation.internal.sharable
+
diff --git a/tastydoc/documentation/scala/annotation/static.md b/tastydoc/documentation/scala/annotation/static.md
new file mode 100644
index 000000000000..7019f6e8b91b
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/static.md
@@ -0,0 +1,6 @@
+scala.annotation
+# class static
+
+final class static extends Annotation with StaticAnnotation
+## Annotations:
+@setter @param @beanSetter @beanGetter @getter @field
diff --git a/tastydoc/documentation/scala/annotation/threadUnsafe.md b/tastydoc/documentation/scala/annotation/threadUnsafe.md
new file mode 100644
index 000000000000..5099ac33f2c5
--- /dev/null
+++ b/tastydoc/documentation/scala/annotation/threadUnsafe.md
@@ -0,0 +1,8 @@
+scala.annotation
+# class threadUnsafe
+
+final class threadUnsafe extends Annotation with StaticAnnotation
+This annotation can only be used on a field which defines a lazy val.
+When this annotation is used, the initialization of the lazy val will use a
+faster mechanism which is not thread-safe.
+
diff --git a/tastydoc/documentation/scala/compiletime/Shape$.md b/tastydoc/documentation/scala/compiletime/Shape$.md
new file mode 100644
index 000000000000..5f6ec63a8d4a
--- /dev/null
+++ b/tastydoc/documentation/scala/compiletime/Shape$.md
@@ -0,0 +1,15 @@
+scala.compiletime
+# object Shape
+
+## Companion class Shape
+
+final object Shape extends Serializable with Sum
+## Concrete Type Members:
+### Case
+case class Case
+A product type `T` with element types `Elems`
+
+### Cases
+case class Cases
+A sum with alternative types `Alts`
+
diff --git a/tastydoc/documentation/scala/compiletime/Shape$/Case.md b/tastydoc/documentation/scala/compiletime/Shape$/Case.md
new file mode 100644
index 000000000000..50fb053de0fb
--- /dev/null
+++ b/tastydoc/documentation/scala/compiletime/Shape$/Case.md
@@ -0,0 +1,12 @@
+scala.compiletime.Shape$
+# case class Case
+
+## Companion object Case
+
+case class Case[T, Elems <: scala.Tuple] extends Shape with Product with Serializable
+A product type `T` with element types `Elems`
+
+## Concrete Value Members:
+### productIterator
+def productIterator: Iterator[Any]
+
diff --git a/tastydoc/documentation/scala/compiletime/Shape$/Cases.md b/tastydoc/documentation/scala/compiletime/Shape$/Cases.md
new file mode 100644
index 000000000000..861fd354fcd5
--- /dev/null
+++ b/tastydoc/documentation/scala/compiletime/Shape$/Cases.md
@@ -0,0 +1,12 @@
+scala.compiletime.Shape$
+# case class Cases
+
+## Companion object Cases
+
+case class Cases[Alts <: scala.Tuple] extends Shape with Product with Serializable
+A sum with alternative types `Alts`
+
+## Concrete Value Members:
+### productIterator
+def productIterator: Iterator[Any]
+
diff --git a/tastydoc/documentation/scala/compiletime/Shape.md b/tastydoc/documentation/scala/compiletime/Shape.md
new file mode 100644
index 000000000000..a8ff62c90f2c
--- /dev/null
+++ b/tastydoc/documentation/scala/compiletime/Shape.md
@@ -0,0 +1,9 @@
+scala.compiletime
+# class Shape
+
+## Companion object Shape
+
+sealed abstract class Shape
+The shape of an ADT.
+This is either a product (`Case`) or a sum (`Cases`) of products.
+
diff --git a/tastydoc/documentation/scala/compiletime/compiletime.md b/tastydoc/documentation/scala/compiletime/compiletime.md
new file mode 100644
index 000000000000..12e8af4c5a5f
--- /dev/null
+++ b/tastydoc/documentation/scala/compiletime/compiletime.md
@@ -0,0 +1,12 @@
+# Package compiletime
+## Members:
+final object package
+final val package: package
+
+final object Shape
+final val Shape: Shape
+
+sealed abstract class Shape
+The shape of an ADT.
+This is either a product (`Case`) or a sum (`Cases`) of products.
+
diff --git a/tastydoc/documentation/scala/compiletime/package$.md b/tastydoc/documentation/scala/compiletime/package$.md
new file mode 100644
index 000000000000..a2cc0dd0499f
--- /dev/null
+++ b/tastydoc/documentation/scala/compiletime/package$.md
@@ -0,0 +1,21 @@
+scala.compiletime
+# object package
+
+final object package extends Serializable
+## Concrete Type Members:
+### S
+type S: Nothing <: [X >: scala.Nothing <: scala.Int] => scala.Int
+
+## Concrete Value Members:
+### constValue
+inline def constValue[T]: T
+
+### constValueOpt
+inline def constValueOpt[T]: Option[T]
+
+### erasedValue
+def erasedValue[T]: T
+
+### error
+inline def error(msg: String, objs: Seq[Any]): Nothing
+
diff --git a/tastydoc/documentation/scala/deriving$.md b/tastydoc/documentation/scala/deriving$.md
new file mode 100644
index 000000000000..c0edbd778b38
--- /dev/null
+++ b/tastydoc/documentation/scala/deriving$.md
@@ -0,0 +1,24 @@
+scala
+# object deriving
+
+final object deriving extends Serializable
+## Concrete Type Members:
+### EmptyProduct
+final object EmptyProduct
+The empty product
+
+### Mirror
+final object Mirror
+### ArrayProduct
+class ArrayProduct
+Helper class to turn arrays into products
+
+### Mirror
+sealed trait Mirror
+Mirrors allows typelevel access to enums, case classes and objects, and their sealed parents.
+
+## Concrete Value Members:
+### productElement
+def productElement[T](x: Any, idx: Int): T
+Helper method to select a product element
+
diff --git a/tastydoc/documentation/scala/deriving$/ArrayProduct.md b/tastydoc/documentation/scala/deriving$/ArrayProduct.md
new file mode 100644
index 000000000000..8cf94ea49ac8
--- /dev/null
+++ b/tastydoc/documentation/scala/deriving$/ArrayProduct.md
@@ -0,0 +1,32 @@
+scala.deriving$
+# class ArrayProduct
+
+class ArrayProduct extends Product
+Helper class to turn arrays into products
+
+## Constructors:
+ArrayProduct(elems: Array[AnyRef])
+ArrayProduct(size: Int)
+
+## Concrete Value Members:
+### canEqual
+def canEqual(that: Any): Boolean
+
+### productArity
+def productArity: Int
+
+### productElement
+def productElement(n: Int): Any
+
+### productIterator
+override def productIterator: Iterator[Any]
+
+### productPrefix
+def productPrefix: String
+
+### update
+def update(n: Int, x: Any): Unit
+
+### elems
+val elems: Array[AnyRef]
+
diff --git a/tastydoc/documentation/scala/deriving$/EmptyProduct$.md b/tastydoc/documentation/scala/deriving$/EmptyProduct$.md
new file mode 100644
index 000000000000..c731d205dcc9
--- /dev/null
+++ b/tastydoc/documentation/scala/deriving$/EmptyProduct$.md
@@ -0,0 +1,25 @@
+scala.deriving$
+# object EmptyProduct
+
+final object EmptyProduct extends ArrayProduct with Serializable
+The empty product
+
+## Concrete Value Members:
+### canEqual
+def canEqual(that: Any): Boolean
+
+### productArity
+def productArity: Int
+
+### productElement
+def productElement(n: Int): Any
+
+### productIterator
+override def productIterator: Iterator[Any]
+
+### productPrefix
+def productPrefix: String
+
+### update
+def update(n: Int, x: Any): Unit
+
diff --git a/tastydoc/documentation/scala/deriving$/Mirror$.md b/tastydoc/documentation/scala/deriving$/Mirror$.md
new file mode 100644
index 000000000000..16e14eb07169
--- /dev/null
+++ b/tastydoc/documentation/scala/deriving$/Mirror$.md
@@ -0,0 +1,42 @@
+scala.deriving$
+# object Mirror
+
+## Companion trait Mirror
+
+final object Mirror extends Serializable
+## Concrete Type Members:
+### Of
+type Of: [T >: scala.Nothing <: scala.Any] => scala.deriving.Mirror {
+ type MirroredType >: T <: T
+ type MirroredMonoType >: T <: T
+ type MirroredElemTypes >: scala.Nothing <: scala.Tuple
+}
+
+### ProductOf
+type ProductOf: [T >: scala.Nothing <: scala.Any] => scala.deriving.Mirror.Product {
+ type MirroredType >: T <: T
+ type MirroredMonoType >: T <: T
+ type MirroredElemTypes >: scala.Nothing <: scala.Tuple
+}
+
+### SumOf
+type SumOf: [T >: scala.Nothing <: scala.Any] => scala.deriving.Mirror.Sum {
+ type MirroredType >: T <: T
+ type MirroredMonoType >: T <: T
+ type MirroredElemTypes >: scala.Nothing <: scala.Tuple
+}
+
+### SingletonProxy
+class SingletonProxy
+A proxy for Scala 2 singletons, which do not inherit `Singleton` directly
+
+### Product
+trait Product
+The Mirror for a product type
+
+### Singleton
+trait Singleton
+### Sum
+trait Sum
+The Mirror for a sum type
+
diff --git a/tastydoc/documentation/scala/deriving$/Mirror$/Product.md b/tastydoc/documentation/scala/deriving$/Mirror$/Product.md
new file mode 100644
index 000000000000..c9ff3de09703
--- /dev/null
+++ b/tastydoc/documentation/scala/deriving$/Mirror$/Product.md
@@ -0,0 +1,11 @@
+scala.deriving$.Mirror$
+# trait Product
+
+trait Product extends Mirror
+The Mirror for a product type
+
+## Concrete Value Members:
+### fromProduct
+def fromProduct(p: Product): MirroredMonoType
+Create a new instance of type `T` with elements taken from product `p`.
+
diff --git a/tastydoc/documentation/scala/deriving$/Mirror$/Singleton.md b/tastydoc/documentation/scala/deriving$/Mirror$/Singleton.md
new file mode 100644
index 000000000000..04572c3295ce
--- /dev/null
+++ b/tastydoc/documentation/scala/deriving$/Mirror$/Singleton.md
@@ -0,0 +1,21 @@
+scala.deriving$.Mirror$
+# trait Singleton
+
+trait Singleton extends Product
+## Concrete Type Members:
+### MirroredElemLabels
+type MirroredElemLabels: Unit
+
+### MirroredElemTypes
+type MirroredElemTypes: Unit
+
+### MirroredMonoType
+type MirroredMonoType: Singleton
+
+### MirroredType
+type MirroredType: Singleton
+
+## Concrete Value Members:
+### fromProduct
+def fromProduct(p: Product): MirroredMonoType
+
diff --git a/tastydoc/documentation/scala/deriving$/Mirror$/SingletonProxy.md b/tastydoc/documentation/scala/deriving$/Mirror$/SingletonProxy.md
new file mode 100644
index 000000000000..52fc0d7e2b4c
--- /dev/null
+++ b/tastydoc/documentation/scala/deriving$/Mirror$/SingletonProxy.md
@@ -0,0 +1,26 @@
+scala.deriving$.Mirror$
+# class SingletonProxy
+
+class SingletonProxy extends Product
+A proxy for Scala 2 singletons, which do not inherit `Singleton` directly
+
+## Constructors:
+SingletonProxy(value: AnyRef)
+
+## Concrete Type Members:
+### MirroredElemLabels
+type MirroredElemLabels: Unit
+
+### MirroredElemTypes
+type MirroredElemTypes: Unit
+
+### MirroredMonoType
+type MirroredMonoType: value
+
+### MirroredType
+type MirroredType: value
+
+## Concrete Value Members:
+### fromProduct
+def fromProduct(p: Product): MirroredMonoType
+
diff --git a/tastydoc/documentation/scala/deriving$/Mirror$/Sum.md b/tastydoc/documentation/scala/deriving$/Mirror$/Sum.md
new file mode 100644
index 000000000000..e25da3ed023f
--- /dev/null
+++ b/tastydoc/documentation/scala/deriving$/Mirror$/Sum.md
@@ -0,0 +1,11 @@
+scala.deriving$.Mirror$
+# trait Sum
+
+trait Sum extends Mirror
+The Mirror for a sum type
+
+## Concrete Value Members:
+### ordinal
+def ordinal(x: MirroredMonoType): Int
+The ordinal number of the case class of `x`. For enums, `ordinal(x) == x.ordinal`
+
diff --git a/tastydoc/documentation/scala/deriving$/Mirror.md b/tastydoc/documentation/scala/deriving$/Mirror.md
new file mode 100644
index 000000000000..a2695d45b607
--- /dev/null
+++ b/tastydoc/documentation/scala/deriving$/Mirror.md
@@ -0,0 +1,24 @@
+scala.deriving$
+# trait Mirror
+
+## Companion object Mirror
+
+sealed trait Mirror
+Mirrors allows typelevel access to enums, case classes and objects, and their sealed parents.
+
+## Concrete Type Members:
+### MirroredElemLabels
+type MirroredElemLabels: Nothing <: Tuple
+The names of the product elements
+
+
+### MirroredLabel
+type MirroredLabel: Nothing <: String
+The name of the type
+
+
+### MirroredMonoType
+type MirroredMonoType: Nothing <: Any
+The mirrored *-type
+
+
diff --git a/tastydoc/documentation/scala/forceInline.md b/tastydoc/documentation/scala/forceInline.md
new file mode 100644
index 000000000000..4be2bcbe2831
--- /dev/null
+++ b/tastydoc/documentation/scala/forceInline.md
@@ -0,0 +1,13 @@
+scala
+# class forceInline
+
+class forceInline extends Annotation with StaticAnnotation
+An annotation on methods that is equivalent to Dotty `inline` modifier,
+except that it does not imply `erased`.
+The annotation should be used instead of the `inline` modifier in code
+that needs to cross compile between Scala 2 and Dotty.
+Note that Scala 2 ignores the `@forceInLine` annotation, and one must use
+both the `@inline` and `@forceInline` annotation to inline across the
+two compilers. E.g.
+```scala```
+
diff --git a/tastydoc/documentation/scala/implicits/LowPriorityNot.md b/tastydoc/documentation/scala/implicits/LowPriorityNot.md
new file mode 100644
index 000000000000..5f110bd84285
--- /dev/null
+++ b/tastydoc/documentation/scala/implicits/LowPriorityNot.md
@@ -0,0 +1,11 @@
+scala.implicits
+# trait LowPriorityNot
+
+trait LowPriorityNot
+## Known subclasses:
+Not
+## Concrete Value Members:
+### default
+implicit def default[T]: Not[T]
+A fallback method used to emulate negation in Scala 2
+
diff --git a/tastydoc/documentation/scala/implicits/Not$.md b/tastydoc/documentation/scala/implicits/Not$.md
new file mode 100644
index 000000000000..5f89d51a9e2d
--- /dev/null
+++ b/tastydoc/documentation/scala/implicits/Not$.md
@@ -0,0 +1,25 @@
+scala.implicits
+# object Not
+
+## Companion class Not
+
+final object Not extends LowPriorityNot with Serializable
+## Concrete Value Members:
+### amb1
+implicit def amb1[T](implicit ev: T): Not[T]
+One of two ambiguous methods used to emulate negation in Scala 2
+
+### amb2
+implicit def amb2[T](implicit ev: T): Not[T]
+One of two ambiguous methods used to emulate negation in Scala 2
+
+### default
+implicit def default[T]: Not[T]
+A fallback method used to emulate negation in Scala 2
+
+### value
+def value: Not[Nothing]
+A value of type `Not` to signal a successful search for `Not[C]` (i.e. a failing
+search for `C`). A reference to this value will be explicitly constructed by Dotty's
+implicit search algorithm
+
diff --git a/tastydoc/documentation/scala/implicits/Not.md b/tastydoc/documentation/scala/implicits/Not.md
new file mode 100644
index 000000000000..1e9a1962ee44
--- /dev/null
+++ b/tastydoc/documentation/scala/implicits/Not.md
@@ -0,0 +1,23 @@
+scala.implicits
+# class Not
+
+## Companion object Not
+
+final class Not[T]
+A special class used to implement negation in implicit search.
+Consider the problem of using implicit `i1` for a query type `D` if an implicit
+for some other class `C` is available, and using an implicit `i2` if no implicit
+value of type `C` is available. If we do not want to prioritize `i1` and `i2` by
+putting them in different traits we can instead define the following:
+ implicit def i1: D(implicit ev: C) = ...
+ implicit def i2: D(implicit ev: Not[C]) = ...
+`Not` is treated specially in implicit search, similar to the way logical negation
+is treated in Prolog: The implicit search for `Not[C]` succeeds if and only if the implicit
+search for `C` fails.
+In Scala 2 this form of negation can be simulated by setting up a conditional
+ambiguous implicit and an unconditional fallback, the way it is done with the
+`default`, `amb1` and `amb2` methods below. Due to the way these two methods are
+defined, `Not` is also usable from Scala 2.
+In Dotty, ambiguity is a global error, and therefore cannot be used to implement negation.
+Instead, `Not` is treated natively in implicit search.
+
diff --git a/tastydoc/documentation/scala/implicits/implicits.md b/tastydoc/documentation/scala/implicits/implicits.md
new file mode 100644
index 000000000000..33862a1414ba
--- /dev/null
+++ b/tastydoc/documentation/scala/implicits/implicits.md
@@ -0,0 +1,24 @@
+# Package implicits
+## Members:
+trait LowPriorityNot
+final object Not
+final val Not: Not
+
+final class Not
+A special class used to implement negation in implicit search.
+Consider the problem of using implicit `i1` for a query type `D` if an implicit
+for some other class `C` is available, and using an implicit `i2` if no implicit
+value of type `C` is available. If we do not want to prioritize `i1` and `i2` by
+putting them in different traits we can instead define the following:
+ implicit def i1: D(implicit ev: C) = ...
+ implicit def i2: D(implicit ev: Not[C]) = ...
+`Not` is treated specially in implicit search, similar to the way logical negation
+is treated in Prolog: The implicit search for `Not[C]` succeeds if and only if the implicit
+search for `C` fails.
+In Scala 2 this form of negation can be simulated by setting up a conditional
+ambiguous implicit and an unconditional fallback, the way it is done with the
+`default`, `amb1` and `amb2` methods below. Due to the way these two methods are
+defined, `Not` is also usable from Scala 2.
+In Dotty, ambiguity is a global error, and therefore cannot be used to implement negation.
+Instead, `Not` is treated natively in implicit search.
+
diff --git a/tastydoc/documentation/scala/internal/MatchCase.md b/tastydoc/documentation/scala/internal/MatchCase.md
new file mode 100644
index 000000000000..e3733154286a
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/MatchCase.md
@@ -0,0 +1,6 @@
+scala.internal
+# class MatchCase
+
+final abstract class MatchCase[Pat, Body]
+A type constructor for a case in a match type.
+
diff --git a/tastydoc/documentation/scala/internal/Quoted$.md b/tastydoc/documentation/scala/internal/Quoted$.md
new file mode 100644
index 000000000000..d79c3d4b5f4b
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/Quoted$.md
@@ -0,0 +1,26 @@
+scala.internal
+# object Quoted
+
+final object Quoted extends Serializable
+## Concrete Type Members:
+### patternBindHole
+@compileTimeOnly class patternBindHole
+A splice of a name in a quoted pattern is desugared by wrapping getting this annotation
+
+## Concrete Value Members:
+### exprQuote
+@compileTimeOnly def exprQuote[T](x: T): Expr[T]
+A term quote is desugared by the compiler into a call to this method
+
+### exprSplice
+@compileTimeOnly def exprSplice[T](x: Expr[T]): T
+A term splice is desugared by the compiler into a call to this method
+
+### patternHole
+@compileTimeOnly def patternHole[T]: T
+A splice in a quoted pattern is desugared by the compiler into a call to this method
+
+### typeQuote
+@compileTimeOnly def typeQuote[T <: scala.AnyKind]: Type[T]
+A type quote is desugared by the compiler into a call to this method
+
diff --git a/tastydoc/documentation/scala/internal/Quoted$/patternBindHole.md b/tastydoc/documentation/scala/internal/Quoted$/patternBindHole.md
new file mode 100644
index 000000000000..7a4641ac3efe
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/Quoted$/patternBindHole.md
@@ -0,0 +1,8 @@
+scala.internal.Quoted$
+# class patternBindHole
+
+class patternBindHole extends Annotation
+A splice of a name in a quoted pattern is desugared by wrapping getting this annotation
+
+## Annotations:
+@compileTimeOnly
diff --git a/tastydoc/documentation/scala/internal/TupledFunction$.md b/tastydoc/documentation/scala/internal/TupledFunction$.md
new file mode 100644
index 000000000000..3ce857ca725b
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/TupledFunction$.md
@@ -0,0 +1,77 @@
+scala.internal
+# object TupledFunction
+
+final object TupledFunction extends Serializable
+## Concrete Value Members:
+### tupledFunction0
+def tupledFunction0[F, G]: TupledFunction[F, G]
+
+### tupledFunction1
+def tupledFunction1[F, G]: TupledFunction[F, G]
+
+### tupledFunction10
+def tupledFunction10[F, G]: TupledFunction[F, G]
+
+### tupledFunction11
+def tupledFunction11[F, G]: TupledFunction[F, G]
+
+### tupledFunction12
+def tupledFunction12[F, G]: TupledFunction[F, G]
+
+### tupledFunction13
+def tupledFunction13[F, G]: TupledFunction[F, G]
+
+### tupledFunction14
+def tupledFunction14[F, G]: TupledFunction[F, G]
+
+### tupledFunction15
+def tupledFunction15[F, G]: TupledFunction[F, G]
+
+### tupledFunction16
+def tupledFunction16[F, G]: TupledFunction[F, G]
+
+### tupledFunction17
+def tupledFunction17[F, G]: TupledFunction[F, G]
+
+### tupledFunction18
+def tupledFunction18[F, G]: TupledFunction[F, G]
+
+### tupledFunction19
+def tupledFunction19[F, G]: TupledFunction[F, G]
+
+### tupledFunction2
+def tupledFunction2[F, G]: TupledFunction[F, G]
+
+### tupledFunction20
+def tupledFunction20[F, G]: TupledFunction[F, G]
+
+### tupledFunction21
+def tupledFunction21[F, G]: TupledFunction[F, G]
+
+### tupledFunction22
+def tupledFunction22[F, G]: TupledFunction[F, G]
+
+### tupledFunction3
+def tupledFunction3[F, G]: TupledFunction[F, G]
+
+### tupledFunction4
+def tupledFunction4[F, G]: TupledFunction[F, G]
+
+### tupledFunction5
+def tupledFunction5[F, G]: TupledFunction[F, G]
+
+### tupledFunction6
+def tupledFunction6[F, G]: TupledFunction[F, G]
+
+### tupledFunction7
+def tupledFunction7[F, G]: TupledFunction[F, G]
+
+### tupledFunction8
+def tupledFunction8[F, G]: TupledFunction[F, G]
+
+### tupledFunction9
+def tupledFunction9[F, G]: TupledFunction[F, G]
+
+### tupledFunctionXXL
+def tupledFunctionXXL[F, G]: TupledFunction[F, G]
+
diff --git a/tastydoc/documentation/scala/internal/TypeBox.md b/tastydoc/documentation/scala/internal/TypeBox.md
new file mode 100644
index 000000000000..aa952d780c0a
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/TypeBox.md
@@ -0,0 +1,14 @@
+scala.internal
+# class TypeBox
+
+final abstract class TypeBox[L <: U, U]
+A type for skolems that are generated during capture conversion. Capture conversion
+narrows the type of a tree whose type has wildcard arguments. A typical situation
+is a tree `t` of type `C[_ >: L <: U]` and an expected type `C[X]` where `X` is an
+instantiatable type variable. To be able to instantiate `X`, we cast the tree to type
+`X[$n.CAP]` where `$n` is a fresh skolem type with underlying type `TypeBox[L, U]`.
+
+## Concrete Type Members:
+### CAP
+type CAP: L <: U
+
diff --git a/tastydoc/documentation/scala/internal/internal.md b/tastydoc/documentation/scala/internal/internal.md
new file mode 100644
index 000000000000..f633a544317b
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/internal.md
@@ -0,0 +1,19 @@
+# Package internal
+## Members:
+final abstract class MatchCase
+A type constructor for a case in a match type.
+
+final object TupledFunction
+final val TupledFunction: TupledFunction
+
+final object Quoted
+final val Quoted: Quoted
+
+final abstract class TypeBox
+A type for skolems that are generated during capture conversion. Capture conversion
+narrows the type of a tree whose type has wildcard arguments. A typical situation
+is a tree `t` of type `C[_ >: L <: U]` and an expected type `C[X]` where `X` is an
+instantiatable type variable. To be able to instantiate `X`, we cast the tree to type
+`X[$n.CAP]` where `$n` is a fresh skolem type with underlying type `TypeBox[L, U]`.
+
+package quoted
\ No newline at end of file
diff --git a/tastydoc/documentation/scala/internal/quoted/FunctionAppliedTo.md b/tastydoc/documentation/scala/internal/quoted/FunctionAppliedTo.md
new file mode 100644
index 000000000000..a0aca9d6de0f
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/quoted/FunctionAppliedTo.md
@@ -0,0 +1,24 @@
+scala.internal.quoted
+# class FunctionAppliedTo
+
+final class FunctionAppliedTo[R] extends Expr[R]
+An Expr representing `'{($f).apply($x1, ..., $xn)}` but it is beta-reduced when the closure is known
+
+## Constructors:
+FunctionAppliedTo(f: Expr[Nothing <: Any], args: Array[Expr[Nothing <: Any]])
+
+## Concrete Value Members:
+### run
+final def run(implicit toolbox: Toolbox): T
+Evaluate the contents of this expression and return the result.
+May throw a FreeVariableError on expressions that came from a macro.
+
+### toString
+override def toString: String
+
+### args
+val args: Array[Expr[Nothing <: Any]]
+
+### f
+val f: Expr[Nothing <: Any]
+
diff --git a/tastydoc/documentation/scala/internal/quoted/LiftedExpr.md b/tastydoc/documentation/scala/internal/quoted/LiftedExpr.md
new file mode 100644
index 000000000000..5f44ac991474
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/quoted/LiftedExpr.md
@@ -0,0 +1,22 @@
+scala.internal.quoted
+# class LiftedExpr
+
+final class LiftedExpr[T] extends Expr[T]
+An Expr backed by a lifted value.
+Values can only be of type Boolean, Byte, Short, Char, Int, Long, Float, Double, Unit, String or Null.
+
+## Constructors:
+LiftedExpr(value: T)
+
+## Concrete Value Members:
+### run
+final def run(implicit toolbox: Toolbox): T
+Evaluate the contents of this expression and return the result.
+May throw a FreeVariableError on expressions that came from a macro.
+
+### toString
+override def toString: String
+
+### value
+val value: T
+
diff --git a/tastydoc/documentation/scala/internal/quoted/Matcher$.md b/tastydoc/documentation/scala/internal/quoted/Matcher$.md
new file mode 100644
index 000000000000..f95c59d2f7c6
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/quoted/Matcher$.md
@@ -0,0 +1,29 @@
+scala.internal.quoted
+# object Matcher
+
+final object Matcher extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply[Tup <: scala.Tuple](scrutineeExpr: Expr[Nothing <: Any])(implicit patternExpr: Expr[Nothing <: Any], reflection: Reflection): Option[Tup]
+Pattern matches an the scrutineeExpr aquainsnt the patternExpr and returns a tuple
+with the matched holes if successful.
+Examples:
+* `Matcher.unapply('{ f(0, myInt) })('{ f(0, myInt) }, _)`
+ will return `Some(())` (where `()` is a tuple of arity 0)
+* `Matcher.unapply('{ f(0, myInt) })('{ f(patternHole[Int], patternHole[Int]) }, _)`
+ will return `Some(Tuple2('{0}, '{ myInt }))`
+* `Matcher.unapply('{ f(0, "abc") })('{ f(0, patternHole[Int]) }, _)`
+ will return `None` due to the missmatch of types in the hole
+
+Holes:
+* scala.internal.Quoted.patternHole[T]: hole that matches an expression `x` of type `Expr[U]`
+ if `U <:< T` and returns `x` as part of the match.
+
+***return*** None if it did not match, `Some(tup)` if it matched where `tup` contains `Expr[Ti]```
+
+***patternExpr*** `Expr[_]` containing the pattern tree
+
+***reflection*** instance of the reflection API (implicitly provided by the macro)
+
+***scrutineeExpr*** `Expr[_]` on which we are pattern matching
+
diff --git a/tastydoc/documentation/scala/internal/quoted/TaggedType.md b/tastydoc/documentation/scala/internal/quoted/TaggedType.md
new file mode 100644
index 000000000000..4a3348321573
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/quoted/TaggedType.md
@@ -0,0 +1,16 @@
+scala.internal.quoted
+# class TaggedType
+
+final class TaggedType[T] extends Type[T]
+An Type backed by a value
+
+## Constructors:
+TaggedType(implicit ct: ClassTag[T])
+
+## Concrete Value Members:
+### toString
+override def toString: String
+
+### ct
+implicit val ct: ClassTag[T]
+
diff --git a/tastydoc/documentation/scala/internal/quoted/TastyExpr.md b/tastydoc/documentation/scala/internal/quoted/TastyExpr.md
new file mode 100644
index 000000000000..94ab6a9683b9
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/quoted/TastyExpr.md
@@ -0,0 +1,24 @@
+scala.internal.quoted
+# class TastyExpr
+
+final class TastyExpr[T] extends Expr[T]
+An Expr backed by a pickled TASTY tree
+
+## Constructors:
+TastyExpr(tasty: Pickled, args: Seq[Any])
+
+## Concrete Value Members:
+### run
+final def run(implicit toolbox: Toolbox): T
+Evaluate the contents of this expression and return the result.
+May throw a FreeVariableError on expressions that came from a macro.
+
+### toString
+override def toString: String
+
+### args
+val args: Seq[Any]
+
+### tasty
+val tasty: Pickled
+
diff --git a/tastydoc/documentation/scala/internal/quoted/TastyTreeExpr.md b/tastydoc/documentation/scala/internal/quoted/TastyTreeExpr.md
new file mode 100644
index 000000000000..392dd9024542
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/quoted/TastyTreeExpr.md
@@ -0,0 +1,24 @@
+scala.internal.quoted
+# class TastyTreeExpr
+
+final class TastyTreeExpr[Tree] extends Expr[Any]
+An Expr backed by a tree. Only the current compiler trees are allowed.
+These expressions are used for arguments of macros. They contain and actual tree
+from the program that is being expanded by the macro.
+May contain references to code defined outside this TastyTreeExpr instance.
+
+## Constructors:
+TastyTreeExpr(tree: Tree)
+
+## Concrete Value Members:
+### run
+final def run(implicit toolbox: Toolbox): T
+Evaluate the contents of this expression and return the result.
+May throw a FreeVariableError on expressions that came from a macro.
+
+### toString
+override def toString: String
+
+### tree
+val tree: Tree
+
diff --git a/tastydoc/documentation/scala/internal/quoted/TastyType.md b/tastydoc/documentation/scala/internal/quoted/TastyType.md
new file mode 100644
index 000000000000..0a9219b04233
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/quoted/TastyType.md
@@ -0,0 +1,19 @@
+scala.internal.quoted
+# class TastyType
+
+final class TastyType[T] extends Type[T]
+A Type backed by a pickled TASTY tree
+
+## Constructors:
+TastyType(tasty: Pickled, args: Seq[Any])
+
+## Concrete Value Members:
+### toString
+override def toString(): String
+
+### args
+val args: Seq[Any]
+
+### tasty
+val tasty: Pickled
+
diff --git a/tastydoc/documentation/scala/internal/quoted/TreeType.md b/tastydoc/documentation/scala/internal/quoted/TreeType.md
new file mode 100644
index 000000000000..1ec905126a11
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/quoted/TreeType.md
@@ -0,0 +1,16 @@
+scala.internal.quoted
+# class TreeType
+
+final class TreeType[Tree] extends Type[Any]
+An Type backed by a tree
+
+## Constructors:
+TreeType(typeTree: Tree)
+
+## Concrete Value Members:
+### toString
+override def toString: String
+
+### typeTree
+val typeTree: Tree
+
diff --git a/tastydoc/documentation/scala/internal/quoted/quoted.md b/tastydoc/documentation/scala/internal/quoted/quoted.md
new file mode 100644
index 000000000000..58d91b7bc12a
--- /dev/null
+++ b/tastydoc/documentation/scala/internal/quoted/quoted.md
@@ -0,0 +1,30 @@
+# Package quoted
+## Members:
+final object Matcher
+final val Matcher: Matcher
+
+final class TastyExpr
+An Expr backed by a pickled TASTY tree
+
+final class TaggedType
+An Type backed by a value
+
+final class TastyTreeExpr
+An Expr backed by a tree. Only the current compiler trees are allowed.
+These expressions are used for arguments of macros. They contain and actual tree
+from the program that is being expanded by the macro.
+May contain references to code defined outside this TastyTreeExpr instance.
+
+final class FunctionAppliedTo
+An Expr representing `'{($f).apply($x1, ..., $xn)}` but it is beta-reduced when the closure is known
+
+final class LiftedExpr
+An Expr backed by a lifted value.
+Values can only be of type Boolean, Byte, Short, Char, Int, Long, Float, Double, Unit, String or Null.
+
+final class TastyType
+A Type backed by a pickled TASTY tree
+
+final class TreeType
+An Type backed by a tree
+
diff --git a/tastydoc/documentation/scala/quoted/Expr$.md b/tastydoc/documentation/scala/quoted/Expr$.md
new file mode 100644
index 000000000000..6e6be09be649
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Expr$.md
@@ -0,0 +1,18 @@
+scala.quoted
+# object Expr
+
+## Companion class Expr
+
+final object Expr extends Serializable
+## Concrete Type Members:
+### TupleOfExpr
+type TupleOfExpr: [Tup >: scala.Nothing <: scala.Tuple] => scala.Tuple.Map[Tup, [+T >: scala.Nothing <: scala.Any] => scala.quoted.Expr[+T]]
+Converts a tuple `(T1, ..., Tn)` to `(Expr[T1], ..., Expr[Tn])`
+
+
+### AsContextualFunction
+class AsContextualFunction
+### AsFunction
+class AsFunction
+### ExprOps
+class ExprOps
diff --git a/tastydoc/documentation/scala/quoted/Expr$/AsContextualFunction.md b/tastydoc/documentation/scala/quoted/Expr$/AsContextualFunction.md
new file mode 100644
index 000000000000..5a892f23974c
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Expr$/AsContextualFunction.md
@@ -0,0 +1,12 @@
+scala.quoted.Expr$
+# class AsContextualFunction
+
+class AsContextualFunction[F, Args <: scala.Tuple, R]
+## Constructors:
+AsContextualFunction(f: Expr[F])(tf: TupledFunction[F, ImplicitFunction1[Args, R]])
+
+## Concrete Value Members:
+### apply
+def apply[G](tg: TupledFunction[G, (TupleOfExpr[Args]) => Expr[R]]): G
+Beta-reduces the function appication. Generates the an expression only containing the body of the function
+
diff --git a/tastydoc/documentation/scala/quoted/Expr$/AsFunction.md b/tastydoc/documentation/scala/quoted/Expr$/AsFunction.md
new file mode 100644
index 000000000000..6169138e1e80
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Expr$/AsFunction.md
@@ -0,0 +1,12 @@
+scala.quoted.Expr$
+# class AsFunction
+
+class AsFunction[F, Args <: scala.Tuple, R]
+## Constructors:
+AsFunction(f: Expr[F])(tf: TupledFunction[F, (Args) => R])
+
+## Concrete Value Members:
+### apply
+def apply[G](tg: TupledFunction[G, (TupleOfExpr[Args]) => Expr[R]]): G
+Beta-reduces the function appication. Generates the an expression only containing the body of the function
+
diff --git a/tastydoc/documentation/scala/quoted/Expr$/ExprOps.md b/tastydoc/documentation/scala/quoted/Expr$/ExprOps.md
new file mode 100644
index 000000000000..004b21994277
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Expr$/ExprOps.md
@@ -0,0 +1,12 @@
+scala.quoted.Expr$
+# class ExprOps
+
+class ExprOps[T]
+## Constructors:
+ExprOps(expr: Expr[T])
+
+## Concrete Value Members:
+### show
+def show(implicit toolbox: Toolbox): String
+Show a source code like representation of this expression
+
diff --git a/tastydoc/documentation/scala/quoted/Expr.md b/tastydoc/documentation/scala/quoted/Expr.md
new file mode 100644
index 000000000000..61911df414e0
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Expr.md
@@ -0,0 +1,12 @@
+scala.quoted
+# class Expr
+
+## Companion object Expr
+
+sealed abstract class Expr[T]
+## Concrete Value Members:
+### run
+final def run(implicit toolbox: Toolbox): T
+Evaluate the contents of this expression and return the result.
+May throw a FreeVariableError on expressions that came from a macro.
+
diff --git a/tastydoc/documentation/scala/quoted/Liftable$.md b/tastydoc/documentation/scala/quoted/Liftable$.md
new file mode 100644
index 000000000000..9776f1cd7b68
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Liftable$.md
@@ -0,0 +1,39 @@
+scala.quoted
+# object Liftable
+
+## Companion class Liftable
+
+final object Liftable extends Serializable
+Some liftable base types. To be completed with at least all types
+that are valid Scala literals. The actual implementation of these
+typed could be in terms of `ast.tpd.Literal`; the test `quotable.scala`
+gives an alternative implementation using just the basic staging system.
+
+## Concrete Value Members:
+### ClassIsLiftable
+implicit def ClassIsLiftable[T]: Liftable[Class[T]]
+
+### Liftable_Boolean_delegate
+implicit val Liftable_Boolean_delegate: Liftable[Boolean]
+
+### Liftable_Char_delegate
+implicit val Liftable_Char_delegate: Liftable[Char]
+
+### Liftable_Double_delegate
+implicit val Liftable_Double_delegate: Liftable[Double]
+
+### Liftable_Float_delegate
+implicit val Liftable_Float_delegate: Liftable[Float]
+
+### Liftable_Int_delegate
+implicit val Liftable_Int_delegate: Liftable[Int]
+
+### Liftable_Long_delegate
+implicit val Liftable_Long_delegate: Liftable[Long]
+
+### Liftable_Short_delegate
+implicit val Liftable_Short_delegate: Liftable[Short]
+
+### Liftable_String_delegate
+implicit val Liftable_String_delegate: Liftable[String]
+
diff --git a/tastydoc/documentation/scala/quoted/Liftable.md b/tastydoc/documentation/scala/quoted/Liftable.md
new file mode 100644
index 000000000000..504427cbdab0
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Liftable.md
@@ -0,0 +1,13 @@
+scala.quoted
+# class Liftable
+
+## Companion object Liftable
+
+abstract class Liftable[T]
+A typeclass for types that can be turned to `quoted.Expr[T]`
+without going through an explicit `'{...}` operation.
+
+## Concrete Value Members:
+### toExpr
+def toExpr(x: T): Expr[T]
+
diff --git a/tastydoc/documentation/scala/quoted/QuoteError$.md b/tastydoc/documentation/scala/quoted/QuoteError$.md
new file mode 100644
index 000000000000..bcc5d9e475fa
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/QuoteError$.md
@@ -0,0 +1,15 @@
+scala.quoted
+# object QuoteError
+
+## Companion class QuoteError
+
+final object QuoteError extends Serializable
+## Concrete Value Members:
+### apply
+def apply(message: => String, from: Expr[Nothing <: Any]): Nothing
+Throws a QuoteError with the given message at the position of the `from` expression
+
+### apply
+def apply(message: => String): Nothing
+Throws a QuoteError with the given message
+
diff --git a/tastydoc/documentation/scala/quoted/QuoteError.md b/tastydoc/documentation/scala/quoted/QuoteError.md
new file mode 100644
index 000000000000..945722ddb708
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/QuoteError.md
@@ -0,0 +1,61 @@
+scala.quoted
+# class QuoteError
+
+## Companion object QuoteError
+
+class QuoteError extends Throwable
+Throwing this error in the implementation of a macro
+will result in a compilation error with the given message.
+
+## Constructors:
+QuoteError(message: String, from: Option[Expr[Nothing <: Any]])
+
+## Concrete Value Members:
+### addSuppressed
+final def addSuppressed(x$0: Throwable): Unit
+
+### fillInStackTrace
+def fillInStackTrace(): Throwable
+
+### getCause
+def getCause(): Throwable
+
+### getLocalizedMessage
+def getLocalizedMessage(): String
+
+### getMessage
+def getMessage(): String
+
+### getStackTrace
+def getStackTrace(): Array[StackTraceElement]
+
+### getStackTraceDepth
+private[lang] def getStackTraceDepth(): Int
+
+### getStackTraceElement
+private[lang] def getStackTraceElement(x$0: Int): StackTraceElement
+
+### getSuppressed
+final def getSuppressed(): Array[Throwable]
+
+### initCause
+def initCause(x$0: Throwable): Throwable
+
+### printStackTrace
+def printStackTrace(x$0: PrintWriter): Unit
+
+### printStackTrace
+def printStackTrace(x$0: PrintStream): Unit
+
+### printStackTrace
+def printStackTrace(): Unit
+
+### setStackTrace
+def setStackTrace(x$0: Array[StackTraceElement]): Unit
+
+### toString
+def toString(): String
+
+### from
+val from: Option[Expr[Nothing <: Any]]
+
diff --git a/tastydoc/documentation/scala/quoted/Toolbox$.md b/tastydoc/documentation/scala/quoted/Toolbox$.md
new file mode 100644
index 000000000000..259a249dc7f6
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Toolbox$.md
@@ -0,0 +1,31 @@
+scala.quoted
+# object Toolbox
+
+## Companion trait Toolbox
+
+final object Toolbox extends Serializable
+## Concrete Type Members:
+### Settings
+final object Settings
+### Settings
+case class Settings
+Setting of the Toolbox instance.
+
+### ToolboxNotFoundException
+class ToolboxNotFoundException
+## Concrete Value Members:
+### make
+def make(appClassloader: ClassLoader)(implicit settings: Settings): Toolbox
+Create a new instance of the toolbox using the the classloader of the application.
+Usuage:
+```
+implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(getClass.getClassLoader)
+```
+``````
+
+***return*** A new instance of the toolbox
+
+***appClassloader*** classloader of the application that generated the quotes
+
+***settings*** toolbox settings
+
diff --git a/tastydoc/documentation/scala/quoted/Toolbox$/Settings$.md b/tastydoc/documentation/scala/quoted/Toolbox$/Settings$.md
new file mode 100644
index 000000000000..1f2e15435e75
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Toolbox$/Settings$.md
@@ -0,0 +1,22 @@
+scala.quoted.Toolbox$
+# object Settings
+
+## Companion case class Settings
+
+final object Settings extends Serializable with Product
+## Concrete Value Members:
+### default
+implicit def default: Settings
+
+### make
+def make(color: Boolean, showRawTree: Boolean, outDir: Option[String], compilerArgs: List[String]): Settings
+Make toolbox settings
+
+***showRawTree*** Do not remove quote tree artifacts
+
+***compilerArgs*** Compiler arguments. Use only if you know what you are doing.
+
+***color*** Print output with colors
+
+***outDir*** Output directory for the compiled quote. If set to None the output will be in memory
+
diff --git a/tastydoc/documentation/scala/quoted/Toolbox$/Settings.md b/tastydoc/documentation/scala/quoted/Toolbox$/Settings.md
new file mode 100644
index 000000000000..e717ef153a55
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Toolbox$/Settings.md
@@ -0,0 +1,27 @@
+scala.quoted.Toolbox$
+# case class Settings
+
+## Companion object Settings
+
+case class Settings extends Product with Serializable
+Setting of the Toolbox instance.
+
+## Constructors:
+Settings(outDir: Option[String], showRawTree: Boolean, compilerArgs: List[String], color: Boolean)
+
+## Concrete Value Members:
+### productIterator
+def productIterator: Iterator[Any]
+
+### color
+val color: Boolean
+
+### compilerArgs
+val compilerArgs: List[String]
+
+### outDir
+val outDir: Option[String]
+
+### showRawTree
+val showRawTree: Boolean
+
diff --git a/tastydoc/documentation/scala/quoted/Toolbox$/ToolboxNotFoundException.md b/tastydoc/documentation/scala/quoted/Toolbox$/ToolboxNotFoundException.md
new file mode 100644
index 000000000000..ebdc62dcc30f
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Toolbox$/ToolboxNotFoundException.md
@@ -0,0 +1,53 @@
+scala.quoted.Toolbox$
+# class ToolboxNotFoundException
+
+class ToolboxNotFoundException extends Exception
+## Constructors:
+ToolboxNotFoundException(msg: String, cause: ClassNotFoundException)
+
+## Concrete Value Members:
+### addSuppressed
+final def addSuppressed(x$0: Throwable): Unit
+
+### fillInStackTrace
+def fillInStackTrace(): Throwable
+
+### getCause
+def getCause(): Throwable
+
+### getLocalizedMessage
+def getLocalizedMessage(): String
+
+### getMessage
+def getMessage(): String
+
+### getStackTrace
+def getStackTrace(): Array[StackTraceElement]
+
+### getStackTraceDepth
+private[lang] def getStackTraceDepth(): Int
+
+### getStackTraceElement
+private[lang] def getStackTraceElement(x$0: Int): StackTraceElement
+
+### getSuppressed
+final def getSuppressed(): Array[Throwable]
+
+### initCause
+def initCause(x$0: Throwable): Throwable
+
+### printStackTrace
+def printStackTrace(x$0: PrintWriter): Unit
+
+### printStackTrace
+def printStackTrace(x$0: PrintStream): Unit
+
+### printStackTrace
+def printStackTrace(): Unit
+
+### setStackTrace
+def setStackTrace(x$0: Array[StackTraceElement]): Unit
+
+### toString
+def toString(): String
+
diff --git a/tastydoc/documentation/scala/quoted/Toolbox.md b/tastydoc/documentation/scala/quoted/Toolbox.md
new file mode 100644
index 000000000000..85ecc4a088e7
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Toolbox.md
@@ -0,0 +1,18 @@
+scala.quoted
+# trait Toolbox
+
+## Companion object Toolbox
+
+trait Toolbox
+## Annotations:
+@implicitNotFound
+## Concrete Value Members:
+### run
+def run[T](expr: Expr[T]): T
+
+### show
+def show[T](tpe: Type[T]): String
+
+### show
+def show[T](expr: Expr[T]): String
+
diff --git a/tastydoc/documentation/scala/quoted/Type$.md b/tastydoc/documentation/scala/quoted/Type$.md
new file mode 100644
index 000000000000..da9b8f837da5
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Type$.md
@@ -0,0 +1,39 @@
+scala.quoted
+# object Type
+
+## Companion class Type
+
+final object Type extends Serializable
+Some basic type tags, currently incomplete
+
+## Concrete Type Members:
+### TypeOps
+final object TypeOps
+## Concrete Value Members:
+### BooleanTag
+implicit val BooleanTag: Type[Boolean]
+
+### ByteTag
+implicit val ByteTag: Type[Byte]
+
+### CharTag
+implicit val CharTag: Type[Char]
+
+### DoubleTag
+implicit val DoubleTag: Type[Double]
+
+### FloatTag
+implicit val FloatTag: Type[Float]
+
+### IntTag
+implicit val IntTag: Type[Int]
+
+### LongTag
+implicit val LongTag: Type[Long]
+
+### ShortTag
+implicit val ShortTag: Type[Short]
+
+### UnitTag
+implicit val UnitTag: Type[Unit]
+
diff --git a/tastydoc/documentation/scala/quoted/Type$/TypeOps$.md b/tastydoc/documentation/scala/quoted/Type$/TypeOps$.md
new file mode 100644
index 000000000000..97c2ac6a0fed
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Type$/TypeOps$.md
@@ -0,0 +1,9 @@
+scala.quoted.Type$
+# object TypeOps
+
+final object TypeOps extends Serializable
+## Concrete Value Members:
+### show
+def show[T](tpe: Type[T])(x$1: Toolbox): String
+Show a source code like representation of this type
+
diff --git a/tastydoc/documentation/scala/quoted/Type.md b/tastydoc/documentation/scala/quoted/Type.md
new file mode 100644
index 000000000000..a48595c2c41b
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/Type.md
@@ -0,0 +1,10 @@
+scala.quoted
+# class Type
+
+## Companion object Type
+
+sealed abstract class Type[T <: scala.AnyKind]
+## Concrete Type Members:
+### $splice
+type $splice: T
+
diff --git a/tastydoc/documentation/scala/quoted/matching/Bind$.md b/tastydoc/documentation/scala/quoted/matching/Bind$.md
new file mode 100644
index 000000000000..f66413a5229e
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/matching/Bind$.md
@@ -0,0 +1,10 @@
+scala.quoted.matching
+# object Bind
+
+## Companion class Bind
+
+final object Bind extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply[T](expr: Expr[T])(implicit reflect: Reflection): Option[Bind[T]]
+
diff --git a/tastydoc/documentation/scala/quoted/matching/Bind.md b/tastydoc/documentation/scala/quoted/matching/Bind.md
new file mode 100644
index 000000000000..a3fae0b72bab
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/matching/Bind.md
@@ -0,0 +1,28 @@
+scala.quoted.matching
+# class Bind
+
+## Companion object Bind
+
+class Bind[T <: scala.AnyKind]
+Bind of an Expr[T] used to know if some Expr[T] is a reference to the binding
+
+***name*** string name of this binding
+
+***id*** unique id used for equality
+
+## Constructors:
+Bind(name: String, id: Object)
+
+## Concrete Value Members:
+### equals
+override def equals(obj: Any): Boolean
+
+### hashCode
+override def hashCode(): Int
+
+### id
+private[Bind] val id: Object
+
+### name
+val name: String
+
diff --git a/tastydoc/documentation/scala/quoted/matching/Const$.md b/tastydoc/documentation/scala/quoted/matching/Const$.md
new file mode 100644
index 000000000000..e122a94cbcf4
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/matching/Const$.md
@@ -0,0 +1,19 @@
+scala.quoted.matching
+# object Const
+
+final object Const extends Serializable
+Matches expressions containing literal constant values and extracts the value.
+It may match expressions of type Boolean, Byte, Short, Int, Long,
+Float, Double, Char, String, ClassTag, scala.Symbol, Null and Unit.
+Usage:
+```
+(x: Expr[B]) match {
+ case Const(value: B) => ...
+}
+```
+``````
+
+## Concrete Value Members:
+### unapply
+def unapply[T](expr: Expr[T])(implicit reflect: Reflection): Option[T]
+
diff --git a/tastydoc/documentation/scala/quoted/matching/ConstSeq$.md b/tastydoc/documentation/scala/quoted/matching/ConstSeq$.md
new file mode 100644
index 000000000000..5662410ff861
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/matching/ConstSeq$.md
@@ -0,0 +1,11 @@
+scala.quoted.matching
+# object ConstSeq
+
+final object ConstSeq extends Serializable
+Literal sequence of literal constant value expressions
+
+## Concrete Value Members:
+### unapply
+def unapply[T](expr: Expr[Seq[T]])(x$2: Reflection): Option[Seq[T]]
+Matches literal sequence of literal constant value expressions
+
diff --git a/tastydoc/documentation/scala/quoted/matching/ExprSeq$.md b/tastydoc/documentation/scala/quoted/matching/ExprSeq$.md
new file mode 100644
index 000000000000..dadd4ca56261
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/matching/ExprSeq$.md
@@ -0,0 +1,11 @@
+scala.quoted.matching
+# object ExprSeq
+
+final object ExprSeq extends Serializable
+Literal sequence of expressions
+
+## Concrete Value Members:
+### unapply
+def unapply[T](expr: Expr[Seq[T]])(implicit reflect: Reflection): Option[Seq[Expr[T]]]
+Matches a literal sequence of expressions
+
diff --git a/tastydoc/documentation/scala/quoted/matching/matching.md b/tastydoc/documentation/scala/quoted/matching/matching.md
new file mode 100644
index 000000000000..9b2932b058b8
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/matching/matching.md
@@ -0,0 +1,51 @@
+# Package matching
+## Members:
+final object ExprSeq
+Literal sequence of expressions
+
+final val ExprSeq: ExprSeq
+Literal sequence of expressions
+
+
+final object Bind
+final val Bind: Bind
+
+class Bind
+Bind of an Expr[T] used to know if some Expr[T] is a reference to the binding
+
+***name*** string name of this binding
+
+***id*** unique id used for equality
+
+final object Const
+Matches expressions containing literal constant values and extracts the value.
+It may match expressions of type Boolean, Byte, Short, Int, Long,
+Float, Double, Char, String, ClassTag, scala.Symbol, Null and Unit.
+Usage:
+```
+(x: Expr[B]) match {
+ case Const(value: B) => ...
+}
+```
+``````
+
+final val Const: Const
+Matches expressions containing literal constant values and extracts the value.
+It may match expressions of type Boolean, Byte, Short, Int, Long,
+Float, Double, Char, String, ClassTag, scala.Symbol, Null and Unit.
+Usage:
+```
+(x: Expr[B]) match {
+ case Const(value: B) => ...
+}
+```
+``````
+
+
+final object ConstSeq
+Literal sequence of literal constant value expressions
+
+final val ConstSeq: ConstSeq
+Literal sequence of literal constant value expressions
+
+
diff --git a/tastydoc/documentation/scala/quoted/package$.md b/tastydoc/documentation/scala/quoted/package$.md
new file mode 100644
index 000000000000..5cc58186598e
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/package$.md
@@ -0,0 +1,9 @@
+scala.quoted
+# object package
+
+final object package extends Serializable
+## Concrete Type Members:
+### ExprOps
+final object ExprOps
+### autolift
+final object autolift
diff --git a/tastydoc/documentation/scala/quoted/package$/ExprOps$.md b/tastydoc/documentation/scala/quoted/package$/ExprOps$.md
new file mode 100644
index 000000000000..a8be9db0d1f3
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/package$/ExprOps$.md
@@ -0,0 +1,11 @@
+scala.quoted.package$
+# object ExprOps
+
+final object ExprOps extends Serializable
+## Concrete Value Members:
+### toExpr
+def toExpr[T](x: T)(x$1: Liftable[T]): Expr[T]
+
+### toExprOfList
+def toExprOfList[T](list: List[Expr[T]])(x$1: Type[T]): Expr[List[T]]
+
diff --git a/tastydoc/documentation/scala/quoted/package$/autolift$.md b/tastydoc/documentation/scala/quoted/package$/autolift$.md
new file mode 100644
index 000000000000..4b18d76f34ed
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/package$/autolift$.md
@@ -0,0 +1,8 @@
+scala.quoted.package$
+# object autolift
+
+final object autolift extends Serializable
+## Concrete Value Members:
+### autoToExpr
+implicit def autoToExpr[T](x: T)(implicit evidence$21: Liftable[T]): Expr[T]
+
diff --git a/tastydoc/documentation/scala/quoted/quoted.md b/tastydoc/documentation/scala/quoted/quoted.md
new file mode 100644
index 000000000000..2b333b8289d5
--- /dev/null
+++ b/tastydoc/documentation/scala/quoted/quoted.md
@@ -0,0 +1,46 @@
+# Package quoted
+## Members:
+final object Expr
+final val Expr: Expr
+
+sealed abstract class Expr
+final object QuoteError
+final val QuoteError: QuoteError
+
+class QuoteError
+Throwing this error in the implementation of a macro
+will result in a compilation error with the given message.
+
+final object package
+final val package: package
+
+final object Liftable
+Some liftable base types. To be completed with at least all types
+that are valid Scala literals. The actual implementation of these
+typed could be in terms of `ast.tpd.Literal`; the test `quotable.scala`
+gives an alternative implementation using just the basic staging system.
+
+final val Liftable: Liftable
+Some liftable base types. To be completed with at least all types
+that are valid Scala literals. The actual implementation of these
+typed could be in terms of `ast.tpd.Literal`; the test `quotable.scala`
+gives an alternative implementation using just the basic staging system.
+
+
+abstract class Liftable
+A typeclass for types that can be turned to `quoted.Expr[T]`
+without going through an explicit `'{...}` operation.
+
+final object Toolbox
+final val Toolbox: Toolbox
+
+@implicitNotFound trait Toolbox
+final object Type
+Some basic type tags, currently incomplete
+
+final val Type: Type
+Some basic type tags, currently incomplete
+
+
+sealed abstract class Type
+package matching
\ No newline at end of file
diff --git a/tastydoc/documentation/scala/reflect/Selectable$.md b/tastydoc/documentation/scala/reflect/Selectable$.md
new file mode 100644
index 000000000000..57671b7bb729
--- /dev/null
+++ b/tastydoc/documentation/scala/reflect/Selectable$.md
@@ -0,0 +1,10 @@
+scala.reflect
+# object Selectable
+
+## Companion class Selectable
+
+final object Selectable extends Serializable
+## Concrete Value Members:
+### reflectiveSelectable
+implicit def reflectiveSelectable(receiver: Any): Selectable
+
diff --git a/tastydoc/documentation/scala/reflect/Selectable.md b/tastydoc/documentation/scala/reflect/Selectable.md
new file mode 100644
index 000000000000..7b2c6e2265f4
--- /dev/null
+++ b/tastydoc/documentation/scala/reflect/Selectable.md
@@ -0,0 +1,19 @@
+scala.reflect
+# class Selectable
+
+## Companion object Selectable
+
+final class Selectable extends AnyVal with Selectable
+## Constructors:
+Selectable(receiver: Any)
+
+## Concrete Value Members:
+### applyDynamic
+override def applyDynamic(name: String, paramTypes: Seq[ClassTag[Nothing <: Any]])(args: Seq[Any]): Any
+
+### selectDynamic
+def selectDynamic(name: String): Any
+
+### receiver
+val receiver: Any
+
diff --git a/tastydoc/documentation/scala/reflect/reflect.md b/tastydoc/documentation/scala/reflect/reflect.md
new file mode 100644
index 000000000000..126b046a7bfb
--- /dev/null
+++ b/tastydoc/documentation/scala/reflect/reflect.md
@@ -0,0 +1,6 @@
+# Package reflect
+## Members:
+final object Selectable
+final val Selectable: Selectable
+
+final class Selectable
diff --git a/tastydoc/documentation/scala/runtime/DynamicTuple$.md b/tastydoc/documentation/scala/runtime/DynamicTuple$.md
new file mode 100644
index 000000000000..57647fa2652e
--- /dev/null
+++ b/tastydoc/documentation/scala/runtime/DynamicTuple$.md
@@ -0,0 +1,47 @@
+scala.runtime
+# object DynamicTuple
+
+final object DynamicTuple extends Serializable
+## Concrete Value Members:
+### concatIterator
+def concatIterator(tup1: Tuple, tup2: Tuple): Iterator[Any]
+
+### cons$Array
+def cons$Array[H](x: H, elems: Array[Object]): Array[Object]
+
+### consIterator
+def consIterator(head: Any, tail: Tuple): Iterator[Any]
+
+### dynamicApply
+def dynamicApply[This <: scala.NonEmptyTuple, N <: scala.Int](self: This, n: Int): Elem[This, N]
+
+### dynamicConcat
+def dynamicConcat[This <: scala.Tuple, That <: scala.Tuple](self: This, that: That): Concat[This, That]
+
+### dynamicCons
+def dynamicCons[H, This <: scala.Tuple](x: H, self: Tuple): *:[H, This]
+
+### dynamicFromArray
+def dynamicFromArray[T <: scala.Tuple](xs: Array[Object]): T
+
+### dynamicFromProduct
+def dynamicFromProduct[T <: scala.Tuple](xs: Product): T
+
+### dynamicSize
+def dynamicSize[This <: scala.Tuple](self: This): Size[This]
+
+### dynamicTail
+def dynamicTail[This <: scala.NonEmptyTuple](self: This): Tail[This]
+
+### dynamicToArray
+def dynamicToArray(self: Tuple): Array[Object]
+
+### productToArray
+def productToArray(self: Product): Array[Object]
+
+### to$Array
+def to$Array(xs: Tuple, n: Int): Array[Object]
+
+### MaxSpecialized
+inline val MaxSpecialized: 22
+
diff --git a/tastydoc/documentation/scala/runtime/EnumValues.md b/tastydoc/documentation/scala/runtime/EnumValues.md
new file mode 100644
index 000000000000..5afc19a8f7e4
--- /dev/null
+++ b/tastydoc/documentation/scala/runtime/EnumValues.md
@@ -0,0 +1,17 @@
+scala.runtime
+# class EnumValues
+
+class EnumValues[E <: scala.Enum]
+## Concrete Value Members:
+### fromInt
+def fromInt: Map[Int, E]
+
+### fromName
+def fromName: Map[String, E]
+
+### register
+def register(v: E): Unit
+
+### values
+def values: Iterable[E]
+
diff --git a/tastydoc/documentation/scala/runtime/quoted/Unpickler$.md b/tastydoc/documentation/scala/runtime/quoted/Unpickler$.md
new file mode 100644
index 000000000000..03f75595cd46
--- /dev/null
+++ b/tastydoc/documentation/scala/runtime/quoted/Unpickler$.md
@@ -0,0 +1,29 @@
+scala.runtime.quoted
+# object Unpickler
+
+final object Unpickler extends Serializable
+Provides methods to unpickle `Expr` and `Type` trees.
+
+## Concrete Type Members:
+### Pickled
+type Pickled: List[String]
+Representation of pickled trees. For now a List[String],
+but it should be changed to some kind of TASTY bundle.
+
+
+## Concrete Value Members:
+### liftedExpr
+def liftedExpr[T](value: T): Expr[T]
+Lift the `value` to an `Expr` tree.
+Values can only be of type Boolean, Byte, Short, Char, Int, Long, Float, Double, Unit, String, Null or Class.
+
+### unpickleExpr
+def unpickleExpr[T](repr: Pickled, args: Seq[Any]): Expr[T]
+Unpickle `repr` which represents a pickled `Expr` tree,
+replacing splice nodes with `args`
+
+### unpickleType
+def unpickleType[T](repr: Pickled, args: Seq[Any]): Type[T]
+Unpickle `repr` which represents a pickled `Type` tree,
+replacing splice nodes with `args`
+
diff --git a/tastydoc/documentation/scala/runtime/quoted/quoted.md b/tastydoc/documentation/scala/runtime/quoted/quoted.md
new file mode 100644
index 000000000000..766726dbdf4a
--- /dev/null
+++ b/tastydoc/documentation/scala/runtime/quoted/quoted.md
@@ -0,0 +1,9 @@
+# Package quoted
+## Members:
+final object Unpickler
+Provides methods to unpickle `Expr` and `Type` trees.
+
+final val Unpickler: Unpickler
+Provides methods to unpickle `Expr` and `Type` trees.
+
+
diff --git a/tastydoc/documentation/scala/runtime/runtime.md b/tastydoc/documentation/scala/runtime/runtime.md
new file mode 100644
index 000000000000..b152fcfd7ac8
--- /dev/null
+++ b/tastydoc/documentation/scala/runtime/runtime.md
@@ -0,0 +1,6 @@
+# Package runtime
+## Members:
+final object DynamicTuple
+final val DynamicTuple: DynamicTuple
+
+class EnumValues
diff --git a/tastydoc/documentation/scala/scala.md b/tastydoc/documentation/scala/scala.md
new file mode 100644
index 000000000000..5791a031908a
--- /dev/null
+++ b/tastydoc/documentation/scala/scala.md
@@ -0,0 +1,191 @@
+# Package scala
+## Members:
+trait Selectable
+final object *:
+final val *:: *:
+
+@showAsInfix sealed abstract class *:
+sealed trait NonEmptyTuple
+Tuple of arbitrary non-zero arity
+
+class forceInline
+An annotation on methods that is equivalent to Dotty `inline` modifier,
+except that it does not imply `erased`.
+The annotation should be used instead of the `inline` modifier in code
+that needs to cross compile between Scala 2 and Dotty.
+Note that Scala 2 ignores the `@forceInLine` annotation, and one must use
+both the `@inline` and `@forceInline` annotation to inline across the
+two compilers. E.g.
+```scala```
+
+@FunctionalInterface abstract class Conversion
+A class for implicit values that can serve as implicit conversions
+The implicit resolution algorithm will act as if there existed
+the additional implicit definition:
+ def $implicitConversion[T, U](x: T)(c: Conversion[T, U]): U = c(x)
+However, the presence of this definition would slow down implicit search since
+its outermost type matches any pair of types. Therefore, implicit search
+contains a special case in `Implicits#discardForView` which emulates the
+conversion in a more efficient way.
+Note that this is a SAM class - function literals are automatically converted
+to the `Conversion` values.
+Also note that in bootstrapped dotty, `Predef.<:<` should inherit from
+`Conversion`. This would cut the number of special cases in `discardForView`
+from two to one.
+
+@implicitNotFound sealed trait TupledFunction
+Type class relating a `FunctionN[..., R]` with an equivalent tupled function `Function1[TupleN[...], R]`
+
+***F*** a function type
+
+***G*** a tupled function type (function of arity 1 receiving a tuple as argument)
+
+trait FunctionXXL
+A function with all parameters grouped in an array.
+
+final object TupleXXL
+final val TupleXXL: TupleXXL
+
+final class TupleXXL
+final object Eql
+Companion object containing a few universally known `Eql` instances.
+Eql instances involving primitive types or the Null type are handled directly in
+the compiler (see Implicits.synthesizedEq), so they are not included here.
+
+final val Eql: Eql
+Companion object containing a few universally known `Eql` instances.
+Eql instances involving primitive types or the Null type are handled directly in
+the compiler (see Implicits.synthesizedEq), so they are not included here.
+
+
+@implicitNotFound sealed trait Eql
+A marker trait indicating that values of type `L` can be compared to values of type `R`.
+
+trait Product0
+final object Product0
+A class for Product0 which was missing from the scala distribution.
+
+final val Product0: Product0
+A class for Product0 which was missing from the scala distribution.
+
+
+trait PolyFunction
+Marker trait for polymorphic function types.
+This is the only trait that can be refined with a polymorphic method,
+as long as that method is called `apply`, e.g.:
+ PolyFunction { def apply[T_1, ..., T_M](x_1: P_1, ..., x_N: P_N): R }
+This type will be erased to FunctionN.
+
+final object deriving
+final val deriving: deriving
+
+final object Tuple
+final val Tuple: Tuple
+
+sealed trait Tuple
+Tuple of arbitrary arity
+
+final object IArray$package
+final val IArray$package: IArray$package
+
+trait Enum
+A base trait of all enum classes
+
+@implicitNotFound final object ValueOf
+`ValueOf[T]` provides the unique value of the type `T` where `T` is a type which has a
+single inhabitant. Eligible types are singleton types of the form `stablePath.type`,
+Unit and singleton types corresponding to value literals.
+Instances of `ValueOf[T]` are provided implicitly for all eligible types. Typically
+an instance would be required where a runtime value corresponding to a type level
+computation is needed.
+For example, we might define a type `Residue[M <: Int]` corresponding to the group of
+integers modulo `M`. We could then mandate that residues can be summed only when they
+are parameterized by the same modulus,
+```scala
+case class Residue[M <: Int](n: Int) extends AnyVal {
+ def +(rhs: Residue[M])(implicit m: ValueOf[M]): Residue[M] =
+ Residue((this.n + rhs.n) % valueOf[M])
+}
+
+val fiveModTen = Residue[10](5)
+val nineModTen = Residue[10](9)
+
+fiveModTen + nineModTen // OK == Residue[10](4)
+
+val fourModEleven = Residue[11](4)
+
+fiveModTen + fourModEleven // compiler error: type mismatch;
+ // found : Residue[11]
+ // required: Residue[10]
+```
+Notice that here the modulus is encoded in the type of the values and so does not
+incur any additional per-value storage cost. When a runtime value of the modulus
+is required in the implementation of `+` it is provided at the call site via the
+implicit argument `m` of type `ValueOf[M]`.
+
+@implicitNotFound final val ValueOf: ValueOf
+`ValueOf[T]` provides the unique value of the type `T` where `T` is a type which has a
+single inhabitant. Eligible types are singleton types of the form `stablePath.type`,
+Unit and singleton types corresponding to value literals.
+Instances of `ValueOf[T]` are provided implicitly for all eligible types. Typically
+an instance would be required where a runtime value corresponding to a type level
+computation is needed.
+For example, we might define a type `Residue[M <: Int]` corresponding to the group of
+integers modulo `M`. We could then mandate that residues can be summed only when they
+are parameterized by the same modulus,
+```scala
+case class Residue[M <: Int](n: Int) extends AnyVal {
+ def +(rhs: Residue[M])(implicit m: ValueOf[M]): Residue[M] =
+ Residue((this.n + rhs.n) % valueOf[M])
+}
+
+val fiveModTen = Residue[10](5)
+val nineModTen = Residue[10](9)
+
+fiveModTen + nineModTen // OK == Residue[10](4)
+
+val fourModEleven = Residue[11](4)
+
+fiveModTen + fourModEleven // compiler error: type mismatch;
+ // found : Residue[11]
+ // required: Residue[10]
+```
+Notice that here the modulus is encoded in the type of the values and so does not
+incur any additional per-value storage cost. When a runtime value of the modulus
+is required in the implementation of `+` it is provided at the call site via the
+implicit argument `m` of type `ValueOf[M]`.
+
+
+@implicitNotFound final class ValueOf
+`ValueOf[T]` provides the unique value of the type `T` where `T` is a type which has a
+single inhabitant. Eligible types are singleton types of the form `stablePath.type`,
+Unit and singleton types corresponding to value literals.
+Instances of `ValueOf[T]` are provided implicitly for all eligible types. Typically
+an instance would be required where a runtime value corresponding to a type level
+computation is needed.
+For example, we might define a type `Residue[M <: Int]` corresponding to the group of
+integers modulo `M`. We could then mandate that residues can be summed only when they
+are parameterized by the same modulus,
+```scala
+case class Residue[M <: Int](n: Int) extends AnyVal {
+ def +(rhs: Residue[M])(implicit m: ValueOf[M]): Residue[M] =
+ Residue((this.n + rhs.n) % valueOf[M])
+}
+
+val fiveModTen = Residue[10](5)
+val nineModTen = Residue[10](9)
+
+fiveModTen + nineModTen // OK == Residue[10](4)
+
+val fourModEleven = Residue[11](4)
+
+fiveModTen + fourModEleven // compiler error: type mismatch;
+ // found : Residue[11]
+ // required: Residue[10]
+```
+Notice that here the modulus is encoded in the type of the values and so does not
+incur any additional per-value storage cost. When a runtime value of the modulus
+is required in the implementation of `+` it is provided at the call site via the
+implicit argument `m` of type `ValueOf[M]`.
+
+package compiletime
package internal
package quoted
\ No newline at end of file
diff --git a/tastydoc/documentation/scala/tasty/Reflection$.md b/tastydoc/documentation/scala/tasty/Reflection$.md
new file mode 100644
index 000000000000..cd23be252489
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/Reflection$.md
@@ -0,0 +1,11 @@
+scala.tasty
+# object Reflection
+
+## Companion class Reflection
+
+final object Reflection extends Serializable
+## Concrete Value Members:
+### macroContext
+def macroContext: Reflection
+Compiler tasty context available in a top level ~ of an inline macro
+
diff --git a/tastydoc/documentation/scala/tasty/Reflection.md b/tastydoc/documentation/scala/tasty/Reflection.md
new file mode 100644
index 000000000000..291c53bee515
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/Reflection.md
@@ -0,0 +1,42 @@
+scala.tasty
+# class Reflection
+
+## Companion object Reflection
+
+class Reflection extends Core with ConstantOps with ContextOps with CommentOps with FlagsOps with IdOps with ImportSelectorOps with QuotedOps with PatternOps with PositionOps with Printers with ReportingOps with RootPosition with SignatureOps with StandardDefinitions with SymbolOps with TreeOps with TreeUtils with TypeOrBoundsOps
+## Constructors:
+Reflection(kernel: Kernel)
+
+## Concrete Type Members:
+### typing
+final object typing
+## Concrete Value Members:
+### error
+def error(msg: => String, source: SourceFile, start: Int, end: Int)(implicit ctx: Context): Unit
+
+### error
+def error(msg: => String, pos: Position)(implicit ctx: Context): Unit
+
+### rootContext
+implicit def rootContext: Context
+Context of the macro expansion
+
+### rootPosition
+def rootPosition: Position
+Root position of this tasty context. For macros it corresponds to the expansion site.
+
+### typeOf
+def typeOf[T](implicit evidence$1: Type[T]): Type
+
+### warning
+def warning(msg: => String, source: SourceFile, start: Int, end: Int)(implicit ctx: Context): Unit
+
+### warning
+def warning(msg: => String, pos: Position)(implicit ctx: Context): Unit
+
+### kernel
+val kernel: Kernel
+
+### util
+val util: TreeUtils{ val reflect: Reflection }
+
diff --git a/tastydoc/documentation/scala/tasty/Reflection/typing$.md b/tastydoc/documentation/scala/tasty/Reflection/typing$.md
new file mode 100644
index 000000000000..3a3c0aa19c3d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/Reflection/typing$.md
@@ -0,0 +1,14 @@
+scala.tasty.Reflection
+# object typing
+
+final object typing extends Serializable
+## Concrete Value Members:
+### typeChecks
+def typeChecks(code: String)(implicit ctx: Context): Boolean
+Whether the code type checks in the given context?
+
+***return*** false if the code has syntax error or type error in the given context, otherwise returns true.
+The code should be a sequence of expressions or statements that may appear in a block.
+
+***code*** The code to be type checked
+
diff --git a/tastydoc/documentation/scala/tasty/file/ConsumeTasty$.md b/tastydoc/documentation/scala/tasty/file/ConsumeTasty$.md
new file mode 100644
index 000000000000..d91d3b41f197
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/file/ConsumeTasty$.md
@@ -0,0 +1,15 @@
+scala.tasty.file
+# object ConsumeTasty
+
+final object ConsumeTasty extends Serializable
+## Concrete Value Members:
+### apply
+def apply(classpath: String, classes: List[String], tastyConsumer: TastyConsumer): Unit
+Load and process TASTy files using TASTy reflect
+
+***tastyConsumer*** consumer that will process the tasty trees
+
+***classes*** classes to be consumed
+
+***classpath*** Classpath where the classes are located
+
diff --git a/tastydoc/documentation/scala/tasty/file/TastyConsumer.md b/tastydoc/documentation/scala/tasty/file/TastyConsumer.md
new file mode 100644
index 000000000000..980cff3664e0
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/file/TastyConsumer.md
@@ -0,0 +1,8 @@
+scala.tasty.file
+# trait TastyConsumer
+
+trait TastyConsumer
+## Concrete Value Members:
+### apply
+def apply(reflect: Reflection)(root: Tree): Unit
+
diff --git a/tastydoc/documentation/scala/tasty/file/file.md b/tastydoc/documentation/scala/tasty/file/file.md
new file mode 100644
index 000000000000..fc6f135746dd
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/file/file.md
@@ -0,0 +1,6 @@
+# Package file
+## Members:
+trait TastyConsumer
+final object ConsumeTasty
+final val ConsumeTasty: ConsumeTasty
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/CommentOps.md b/tastydoc/documentation/scala/tasty/reflect/CommentOps.md
new file mode 100644
index 000000000000..bd9d809b28c7
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/CommentOps.md
@@ -0,0 +1,7 @@
+scala.tasty.reflect
+# trait CommentOps
+
+trait CommentOps extends Core
+## Concrete Type Members:
+### CommentAPI
+class CommentAPI
diff --git a/tastydoc/documentation/scala/tasty/reflect/CommentOps/CommentAPI.md b/tastydoc/documentation/scala/tasty/reflect/CommentOps/CommentAPI.md
new file mode 100644
index 000000000000..2dc7bdcb9a95
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/CommentOps/CommentAPI.md
@@ -0,0 +1,20 @@
+scala.tasty.reflect.CommentOps
+# class CommentAPI
+
+class CommentAPI
+## Constructors:
+CommentAPI(self: Comment)
+
+## Concrete Value Members:
+### expanded
+def expanded: Option[String]
+Expanded comment string, if any
+
+### raw
+def raw: String
+Raw comment string
+
+### usecases
+def usecases: List[(String, Option[DefDef])]
+List of usecases and their corresponding trees, if any
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps.md
new file mode 100644
index 000000000000..b80a4ad5a121
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect
+# trait ConstantOps
+
+trait ConstantOps extends Core
+## Concrete Type Members:
+### Constant
+final object Constant
+Module of Constant literals
+
+### ConstantAPI
+class ConstantAPI
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$.md
new file mode 100644
index 000000000000..8d8d8a5dc6e4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$.md
@@ -0,0 +1,59 @@
+scala.tasty.reflect.ConstantOps
+# object Constant
+
+final object Constant extends Serializable
+Module of Constant literals
+
+## Concrete Type Members:
+### Boolean
+final object Boolean
+Module of Boolean literals
+
+### Byte
+final object Byte
+Module of Byte literals
+
+### Char
+final object Char
+Module of Char literals
+
+### ClassTag
+final object ClassTag
+Module of ClassTag literals
+
+### Double
+final object Double
+Module of Double literals
+
+### Float
+final object Float
+Module of Float literals
+
+### Int
+final object Int
+Module of Int literals
+
+### Long
+final object Long
+Module of Long literals
+
+### Null
+final object Null
+Module of Null literals
+
+### Short
+final object Short
+Module of Short literals
+
+### String
+final object String
+Module of String literals
+
+### Symbol
+final object Symbol
+Module of scala.Symbol literals
+
+### Unit
+final object Unit
+Module of Null literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Boolean$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Boolean$.md
new file mode 100644
index 000000000000..2d03a8e77a42
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Boolean$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object Boolean
+
+final object Boolean extends Serializable
+Module of Boolean literals
+
+## Concrete Value Members:
+### apply
+def apply(x: Boolean): Constant
+Boolean literal
+
+### unapply
+def unapply(constant: Constant): Option[Boolean]
+Extractor for Boolean literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Byte$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Byte$.md
new file mode 100644
index 000000000000..9b1f4eb362b1
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Byte$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object Byte
+
+final object Byte extends Serializable
+Module of Byte literals
+
+## Concrete Value Members:
+### apply
+def apply(x: Byte): Constant
+Byte literal
+
+### unapply
+def unapply(constant: Constant): Option[Byte]
+Extractor for Byte literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Char$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Char$.md
new file mode 100644
index 000000000000..8ec76f2ebcc3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Char$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object Char
+
+final object Char extends Serializable
+Module of Char literals
+
+## Concrete Value Members:
+### apply
+def apply(x: Char): Constant
+Char literal
+
+### unapply
+def unapply(constant: Constant): Option[Char]
+Extractor for Char literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/ClassTag$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/ClassTag$.md
new file mode 100644
index 000000000000..6ce153da7b3f
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/ClassTag$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object ClassTag
+
+final object ClassTag extends Serializable
+Module of ClassTag literals
+
+## Concrete Value Members:
+### apply
+def apply[T](implicit x: ClassTag[T]): Constant
+scala.reflect.ClassTag literal
+
+### unapply
+def unapply(constant: Constant): Option[Type]
+Extractor for ClassTag literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Double$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Double$.md
new file mode 100644
index 000000000000..6943031c28a3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Double$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object Double
+
+final object Double extends Serializable
+Module of Double literals
+
+## Concrete Value Members:
+### apply
+def apply(x: Double): Constant
+Double literal
+
+### unapply
+def unapply(constant: Constant): Option[Double]
+Extractor for Double literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Float$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Float$.md
new file mode 100644
index 000000000000..20519c44757b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Float$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object Float
+
+final object Float extends Serializable
+Module of Float literals
+
+## Concrete Value Members:
+### apply
+def apply(x: Float): Constant
+Float literal
+
+### unapply
+def unapply(constant: Constant): Option[Float]
+Extractor for Float literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Int$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Int$.md
new file mode 100644
index 000000000000..255e7ff56f7f
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Int$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object Int
+
+final object Int extends Serializable
+Module of Int literals
+
+## Concrete Value Members:
+### apply
+def apply(x: Int): Constant
+Int literal
+
+### unapply
+def unapply(constant: Constant): Option[Int]
+Extractor for Int literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Long$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Long$.md
new file mode 100644
index 000000000000..e125ca2c7294
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Long$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object Long
+
+final object Long extends Serializable
+Module of Long literals
+
+## Concrete Value Members:
+### apply
+def apply(x: Long): Constant
+Long literal
+
+### unapply
+def unapply(constant: Constant): Option[Long]
+Extractor for Long literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Null$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Null$.md
new file mode 100644
index 000000000000..019b60c45902
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Null$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object Null
+
+final object Null extends Serializable
+Module of Null literals
+
+## Concrete Value Members:
+### apply
+def apply(): Constant
+`null` literal
+
+### unapply
+def unapply(constant: Constant): Boolean
+Extractor for Null literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Short$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Short$.md
new file mode 100644
index 000000000000..ecc4c4fedb3c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Short$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object Short
+
+final object Short extends Serializable
+Module of Short literals
+
+## Concrete Value Members:
+### apply
+def apply(x: Short): Constant
+Short literal
+
+### unapply
+def unapply(constant: Constant): Option[Short]
+Extractor for Short literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/String$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/String$.md
new file mode 100644
index 000000000000..4217e457ae2a
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/String$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object String
+
+final object String extends Serializable
+Module of String literals
+
+## Concrete Value Members:
+### apply
+def apply(x: String): Constant
+String literal
+
+### unapply
+def unapply(constant: Constant): Option[String]
+Extractor for String literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Symbol$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Symbol$.md
new file mode 100644
index 000000000000..255f763bc32b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Symbol$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object Symbol
+
+final object Symbol extends Serializable
+Module of scala.Symbol literals
+
+## Concrete Value Members:
+### apply
+def apply(x: Symbol): Constant
+scala.Symbol literal
+
+### unapply
+def unapply(constant: Constant): Option[Symbol]
+Extractor for scala.Symbol literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Unit$.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Unit$.md
new file mode 100644
index 000000000000..ca7c41fe1fc4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/Constant$/Unit$.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.ConstantOps.Constant$
+# object Unit
+
+final object Unit extends Serializable
+Module of Null literals
+
+## Concrete Value Members:
+### apply
+def apply(): Constant
+Unit `()` literal
+
+### unapply
+def unapply(constant: Constant): Boolean
+Extractor for Unit literals
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ConstantOps/ConstantAPI.md b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/ConstantAPI.md
new file mode 100644
index 000000000000..b58c45f470df
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ConstantOps/ConstantAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.ConstantOps
+# class ConstantAPI
+
+class ConstantAPI
+## Constructors:
+ConstantAPI(const: Constant)
+
+## Concrete Value Members:
+### value
+def value: Any
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ContextOps.md b/tastydoc/documentation/scala/tasty/reflect/ContextOps.md
new file mode 100644
index 000000000000..326745de25a0
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ContextOps.md
@@ -0,0 +1,12 @@
+scala.tasty.reflect
+# trait ContextOps
+
+trait ContextOps extends Core
+## Concrete Type Members:
+### ContextAPI
+class ContextAPI
+## Concrete Value Members:
+### rootContext
+implicit def rootContext: Context
+Context of the macro expansion
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ContextOps/ContextAPI.md b/tastydoc/documentation/scala/tasty/reflect/ContextOps/ContextAPI.md
new file mode 100644
index 000000000000..86d4863204a5
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ContextOps/ContextAPI.md
@@ -0,0 +1,28 @@
+scala.tasty.reflect.ContextOps
+# class ContextAPI
+
+class ContextAPI
+## Constructors:
+ContextAPI(self: Context)
+
+## Concrete Value Members:
+### owner
+def owner: Symbol
+Returns the owner of the context
+
+### printColors
+def printColors: Boolean
+Returns true if the generated strings are allowed to use colors
+
+### source
+def source: Path
+Returns the source file being compiled. The path is relative to the current working directory.
+
+### withColors
+def withColors: Context
+Returns a new context where printColors is true
+
+### withoutColors
+def withoutColors: Context
+Returns a new context where printColors is false
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Core.md b/tastydoc/documentation/scala/tasty/reflect/Core.md
new file mode 100644
index 000000000000..2d1e0f820514
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Core.md
@@ -0,0 +1,644 @@
+scala.tasty.reflect
+# trait Core
+
+trait Core
+Tasty reflect abstract types
+```none```
++- Tree -+- PackageClause
+ +- Import
+ +- Statement -+- Definition --+- PackageDef
+ | | +- ClassDef
+ | | +- TypeDef
+ | | +- DefDef
+ | | +- ValDef
+ | |
+ | +- Term --------+- Ref -+- Ident
+ | | +- Select
+ | |
+ | +- Literal
+ | +- This
+ | +- New
+ | +- NamedArg
+ | +- Apply
+ | +- TypeApply
+ | +- Super
+ | +- Typed
+ | +- Assign
+ | +- Block
+ | +- Lambda
+ | +- If
+ | +- Match
+ | +- ImpliedMatch
+ | +- Try
+ | +- Return
+ | +- Repeated
+ | +- Inlined
+ | +- SelectOuter
+ | +- While
+ |
+ |
+ +- TypeTree ----+- Inferred
+ | +- TypeIdent
+ | +- TypeSelect
+ | +- Projection
+ | +- Singleton
+ | +- Refined
+ | +- Applied
+ | +- Annotated
+ | +- MatchTypeTree
+ | +- ByName
+ | +- LambdaTypeTree
+ | +- TypeBind
+ | +- TypeBlock
+ |
+ +- TypeBoundsTree
+ +- WildcardTypeTree
+ +- CaseDef
+ +- TypeCaseDef
++- Pattern --+- Value
+ +- Bind
+ +- Unapply
+ +- Alternatives
+ +- TypeTest
+ +- WildcardPattern
+ +- NoPrefix
++- TypeOrBounds -+- TypeBounds
+ |
+ +- Type -------+- ConstantType
+ +- SymRef
+ +- TermRef
+ +- TypeRef
+ +- SuperType
+ +- Refinement
+ +- AppliedType
+ +- AnnotatedType
+ +- AndType
+ +- OrType
+ +- MatchType
+ +- ByNameType
+ +- ParamRef
+ +- ThisType
+ +- RecursiveThis
+ +- RecursiveType
+ +- LambdaType[ParamInfo <: TypeOrBounds] -+- MethodType
+ +- PolyType
+ +- TypeLambda
++- ImportSelector -+- SimpleSelector
+ +- RenameSelector
+ +- OmitSelector
++- Id
++- Signature
++- Position
++- Comment
++- Constant
++- Symbol --+- PackageDefSymbol
+ |
+ +- TypeSymbol -+- ClassDefSymbol
+ | +- TypeDefSymbol
+ | +- TypeBindSymbol
+ |
+ +- TermSymbol -+- DefDefSymbol
+ | +- ValDefSymbol
+ | +- BindSymbol
+ |
+ +- NoSymbol
++- Flags
+```
+```
+
+## Concrete Type Members:
+### Alternatives
+type Alternatives: Alternatives
+Pattern representing `X | Y | ...` alternatives.
+
+
+### AndType
+type AndType: AndType
+Intersection type `T & U`
+
+
+### Annotated
+type Annotated: Annotated
+Type tree representing an annotated type
+
+
+### AnnotatedType
+type AnnotatedType: AnnotatedType
+A type with an anottation `T @foo`
+
+
+### Applied
+type Applied: Applied
+Type tree representing a type application
+
+
+### AppliedType
+type AppliedType: AppliedType
+A higher kinded type applied to some types `T[U]`
+
+
+### Apply
+type Apply: Apply
+Tree an application of arguments. It represents a single list of arguments, multiple argument lists will have nested `Apply`s
+
+
+### Assign
+type Assign: Assign
+Tree representing an assignment `x = y` in the source code
+
+
+### Bind
+type Bind: Bind
+Pattern representing a `_ @ _` binding.
+
+
+### BindSymbol
+type BindSymbol: BindSymbol
+Symbol representing a bind definition.
+
+
+### Block
+type Block: Block
+Tree representing a block `{ ... }` in the source code
+
+
+### ByName
+type ByName: ByName
+Type tree representing a by name parameter
+
+
+### ByNameType
+type ByNameType: ByNameType
+Type of a by by name parameter
+
+
+### CaseDef
+type CaseDef: CaseDef
+Branch of a pattern match or catch clause
+
+
+### ClassDef
+type ClassDef: ClassDef
+Tree representing a class definition. This includes annonymus class definitions and the class of a module object
+
+
+### ClassDefSymbol
+type ClassDefSymbol: ClassDefSymbol
+Symbol of a class definition. This includes anonymous class definitions and the class of a module object.
+
+
+### Comment
+type Comment: Comment
+Comment
+
+
+### Constant
+type Constant: Constant
+Constant value represented as the constant itself
+
+
+### ConstantType
+type ConstantType: ConstantType
+A singleton type representing a known constant value
+
+
+### Context
+type Context: Context
+Compilation context
+
+
+### DefDef
+type DefDef: DefDef
+Tree representing a method definition in the source code
+
+
+### DefDefSymbol
+type DefDefSymbol: DefDefSymbol
+Symbol representing a method definition.
+
+
+### Definition
+type Definition: Definition
+Tree representing a definition in the source code. It can be `PackageDef`, `ClassDef`, `TypeDef`, `DefDef` or `ValDef`
+
+
+### Flags
+type Flags: Flags
+FlagSet of a Symbol
+
+
+### Id
+type Id: Id
+Untyped identifier
+
+
+### Ident
+type Ident: Ident
+Tree representing a reference to definition with a given name
+
+
+### If
+type If: If
+Tree representing an if/then/else `if (...) ... else ...` in the source code
+
+
+### ImpliedMatch
+type ImpliedMatch: ImpliedMatch
+Tree representing a pattern match `delegate match { ... }` in the source code
+
+
+### Import
+type Import: Import
+Tree representing an import in the source code
+
+
+### ImportSelector
+type ImportSelector: ImportSelector
+Import selectors:
+ * SimpleSelector: `.bar` in `import foo.bar`
+ * RenameSelector: `.{bar => baz}` in `import foo.{bar => baz}`
+ * OmitSelector: `.{bar => _}` in `import foo.{bar => _}`
+
+
+### Inferred
+type Inferred: Inferred
+Type tree representing an inferred type
+
+
+### Inlined
+type Inlined: Inlined
+Tree representing the scope of an inlined tree
+
+
+### Lambda
+type Lambda: Lambda
+Tree representing a lambda `(...) => ...` in the source code
+
+
+### LambdaType
+type LambdaType: [ParamInfo >: scala.Nothing <: scala.Any] => Core.this.kernel.LambdaType[ParamInfo]
+Common abstraction for lambda types (MethodType, PolyType and TypeLambda).
+
+
+### LambdaTypeTree
+type LambdaTypeTree: LambdaTypeTree
+Type tree representing a lambda abstraction type
+
+
+### Literal
+type Literal: Literal
+Tree representing a literal value in the source code
+
+
+### Match
+type Match: Match
+Tree representing a pattern match `x match { ... }` in the source code
+
+
+### MatchType
+type MatchType: MatchType
+Type match `T match { case U => ... }`
+
+
+### MatchTypeTree
+type MatchTypeTree: MatchTypeTree
+Type tree representing a type match
+
+
+### MethodType
+type MethodType: MethodType
+Type of the definition of a method taking a single list of parameters. It's return type may be a MethodType.
+
+
+### NamedArg
+type NamedArg: NamedArg
+Tree representing an argument passed with an explicit name. Such as `arg1 = x` in `foo(arg1 = x)`
+
+
+### New
+type New: New
+Tree representing `new` in the source code
+
+
+### NoPrefix
+type NoPrefix: NoPrefix
+NoPrefix for a type selection
+
+
+### NoSymbol
+type NoSymbol: NoSymbol
+No symbol available.
+
+
+### OmitSelector
+type OmitSelector: OmitSelector
+
+### OrType
+type OrType: OrType
+Union type `T | U`
+
+
+### PackageClause
+type PackageClause: PackageClause
+Tree representing a pacakage clause in the source code
+
+
+### PackageDef
+type PackageDef: PackageDef
+Tree representing a package definition. This includes definitions in all source files
+
+
+### PackageDefSymbol
+type PackageDefSymbol: PackageDefSymbol
+Symbol of a package definition
+
+
+### ParamRef
+type ParamRef: ParamRef
+Type of a parameter reference
+
+
+### Pattern
+type Pattern: Pattern
+Pattern tree of the pattern part of a CaseDef
+
+
+### PolyType
+type PolyType: PolyType
+Type of the definition of a method taking a list of type parameters. It's return type may be a MethodType.
+
+
+### Position
+type Position: Position
+Position in a source file
+
+
+### Projection
+type Projection: Projection
+Type tree representing a selection of definition with a given name on a given type prefix
+
+
+### RecursiveThis
+type RecursiveThis: RecursiveThis
+A type that is recursively defined `this`
+
+
+### RecursiveType
+type RecursiveType: RecursiveType
+A type that is recursively defined
+
+
+### Ref
+type Ref: Ref
+Tree representing a reference to definition
+
+
+### Refined
+type Refined: Refined
+Type tree representing a type refinement
+
+
+### Refinement
+type Refinement: Refinement
+A type with a type refinement `T { type U }`
+
+
+### RenameSelector
+type RenameSelector: RenameSelector
+
+### Repeated
+type Repeated: Repeated
+Tree representing a variable argument list in the source code
+
+
+### Return
+type Return: Return
+Tree representing a `return` in the source code
+
+
+### Select
+type Select: Select
+Tree representing a selection of definition with a given name on a given prefix
+
+
+### SelectOuter
+type SelectOuter: SelectOuter
+Tree representing a selection of definition with a given name on a given prefix and number of nested scopes of inlined trees
+
+
+### Settings
+type Settings: Settings
+Settings
+
+
+### Signature
+type Signature: Signature
+JVM signature of a method
+
+
+### SimpleSelector
+type SimpleSelector: SimpleSelector
+
+### Singleton
+type Singleton: Singleton
+Type tree representing a singleton type
+
+
+### SourceFile
+type SourceFile: SourceFile
+Scala source file
+
+
+### Statement
+type Statement: Statement
+Tree representing a statement in the source code
+
+
+### Super
+type Super: Super
+Tree representing `super` in the source code
+
+
+### SuperType
+type SuperType: SuperType
+Type of a `super` refernce
+
+
+### SymRef
+type SymRef: SymRef
+Type of a reference to a symbol
+
+
+### Symbol
+type Symbol: Symbol
+Symbol of a definition.
+Then can be compared with == to know if the definition is the same.
+
+
+### Term
+type Term: Term
+Tree representing an expression in the source code
+
+
+### TermRef
+type TermRef: TermRef
+Type of a reference to a term
+
+
+### TermSymbol
+type TermSymbol: TermSymbol
+Symbol representing a term definition.
+
+
+### This
+type This: This
+Tree representing `this` in the source code
+
+
+### ThisType
+type ThisType: ThisType
+Type of `this`
+
+
+### Tree
+type Tree: Tree
+Tree representing code written in the source
+
+
+### Try
+type Try: Try
+Tree representing a try catch `try x catch { ... } finally { ... }` in the source code
+
+
+### Type
+type Type: Type
+A type
+
+
+### TypeApply
+type TypeApply: TypeApply
+Tree an application of type arguments
+
+
+### TypeBind
+type TypeBind: TypeBind
+Type tree representing a type binding
+
+
+### TypeBindSymbol
+type TypeBindSymbol: TypeBindSymbol
+Symbol representing a type bind definition.
+
+
+### TypeBlock
+type TypeBlock: TypeBlock
+Type tree within a block with aliases `{ type U1 = ... ; T[U1, U2] }`
+
+
+### TypeBounds
+type TypeBounds: TypeBounds
+Type bounds
+
+
+### TypeBoundsTree
+type TypeBoundsTree: TypeBoundsTree
+Type tree representing a type bound written in the source
+
+
+### TypeCaseDef
+type TypeCaseDef: TypeCaseDef
+Branch of a type pattern match
+
+
+### TypeDef
+type TypeDef: TypeDef
+Tree representing a type (paramter or member) definition in the source code
+
+
+### TypeDefSymbol
+type TypeDefSymbol: TypeDefSymbol
+Symbol of a type (parameter or member) definition.
+
+
+### TypeIdent
+type TypeIdent: TypeIdent
+Type tree representing a reference to definition with a given name
+
+
+### TypeLambda
+type TypeLambda: TypeLambda
+Type of the definition of a type lambda taking a list of type parameters. It's return type may be a TypeLambda.
+
+
+### TypeOrBounds
+type TypeOrBounds: TypeOrBounds
+Type or bounds
+
+
+### TypeRef
+type TypeRef: TypeRef
+Type of a reference to a type
+
+
+### TypeSelect
+type TypeSelect: TypeSelect
+Type tree representing a selection of definition with a given name on a given term prefix
+
+
+### TypeSymbol
+type TypeSymbol: TypeSymbol
+Symbol representing a type definition.
+
+
+### TypeTest
+type TypeTest: TypeTest
+Pattern representing a `x: Y` type test.
+
+
+### TypeTree
+type TypeTree: TypeTree
+Type tree representing a type written in the source
+
+
+### Typed
+type Typed: Typed
+Tree representing a type ascription `x: T` in the source code
+
+
+### Unapply
+type Unapply: Unapply
+Pattern representing a `Xyz(...)` unapply.
+
+
+### ValDef
+type ValDef: ValDef
+Tree representing a value definition in the source code This inclues `val`, `lazy val`, `var`, `object` and parameter defintions.
+
+
+### ValDefSymbol
+type ValDefSymbol: ValDefSymbol
+Symbol representing a value definition. This includes `val`, `lazy val`, `var`, `object` and parameter definitions.
+
+
+### Value
+type Value: Value
+Pattern representing a value. This includes `1`, ```x``` and `_`
+
+
+### While
+type While: While
+Tree representing a while loop
+
+
+### WildcardPattern
+type WildcardPattern: WildcardPattern
+Pattern representing a `_` pattern
+
+
+### WildcardTypeTree
+type WildcardTypeTree: WildcardTypeTree
+Type tree representing wildcard type bounds written in the source.
+The wildcard type `_` (for example in in `List[_]`) will be a type tree that
+represents a type but has `TypeBound`a inside.
+
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ExprCastError.md b/tastydoc/documentation/scala/tasty/reflect/ExprCastError.md
new file mode 100644
index 000000000000..6efa42837bdf
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ExprCastError.md
@@ -0,0 +1,53 @@
+scala.tasty.reflect
+# class ExprCastError
+
+class ExprCastError extends Throwable
+## Constructors:
+ExprCastError(msg: String)
+
+## Concrete Value Members:
+### addSuppressed
+final def addSuppressed(x$0: Throwable): Unit
+
+### fillInStackTrace
+def fillInStackTrace(): Throwable
+
+### getCause
+def getCause(): Throwable
+
+### getLocalizedMessage
+def getLocalizedMessage(): String
+
+### getMessage
+def getMessage(): String
+
+### getStackTrace
+def getStackTrace(): Array[StackTraceElement]
+
+### getStackTraceDepth
+private[lang] def getStackTraceDepth(): Int
+
+### getStackTraceElement
+private[lang] def getStackTraceElement(x$0: Int): StackTraceElement
+
+### getSuppressed
+final def getSuppressed(): Array[Throwable]
+
+### initCause
+def initCause(x$0: Throwable): Throwable
+
+### printStackTrace
+def printStackTrace(x$0: PrintWriter): Unit
+
+### printStackTrace
+def printStackTrace(x$0: PrintStream): Unit
+
+### printStackTrace
+def printStackTrace(): Unit
+
+### setStackTrace
+def setStackTrace(x$0: Array[StackTraceElement]): Unit
+
+### toString
+def toString(): String
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/FlagsOps.md b/tastydoc/documentation/scala/tasty/reflect/FlagsOps.md
new file mode 100644
index 000000000000..8da48c8dcfb2
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/FlagsOps.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect
+# trait FlagsOps
+
+trait FlagsOps extends Core
+## Concrete Type Members:
+### Flags
+final object Flags
+### FlagsAPI
+class FlagsAPI
diff --git a/tastydoc/documentation/scala/tasty/reflect/FlagsOps/Flags$.md b/tastydoc/documentation/scala/tasty/reflect/FlagsOps/Flags$.md
new file mode 100644
index 000000000000..5516883235a3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/FlagsOps/Flags$.md
@@ -0,0 +1,145 @@
+scala.tasty.reflect.FlagsOps
+# object Flags
+
+final object Flags extends Serializable
+## Concrete Value Members:
+### Abstract
+def Abstract: Flags
+Is this symbol `abstract`
+
+### Artifact
+def Artifact: Flags
+Is this symbol to be tagged Java Synthetic
+
+### Case
+def Case: Flags
+Is this symbol `case`
+
+### CaseAcessor
+def CaseAcessor: Flags
+Is this symbol a getter for case class parameter
+
+### Contravariant
+def Contravariant: Flags
+Is this symbol a type parameter marked as contravariant `-`
+
+### Covariant
+def Covariant: Flags
+Is this symbol a type parameter marked as covariant `+`
+
+### DefaultParameterized
+def DefaultParameterized: Flags
+Is this symbol a method with default parameters
+
+### EmptyFlags
+def EmptyFlags: Flags
+The empty set of flags
+
+### Enum
+def Enum: Flags
+Is this symbol an enum
+
+### Erased
+def Erased: Flags
+Is this symbol `erased`
+
+### FieldAccessor
+def FieldAccessor: Flags
+Is this symbol a getter or a setter
+
+### Final
+def Final: Flags
+Is this symbol `final`
+
+### Given
+def Given: Flags
+Is this symbol an inferable ("given") parameter
+
+### Implicit
+def Implicit: Flags
+Is this symbol `implicit`
+
+### Inline
+def Inline: Flags
+Is this symbol `inline`
+
+### JavaDefined
+def JavaDefined: Flags
+Is this symbol defined in a Java class
+
+### Lazy
+def Lazy: Flags
+Is this symbol `lazy`
+
+### Local
+def Local: Flags
+Is this symbol local? Used in conjunction with private/private[Type] to mean private[this] extends Modifier proctected[this]
+
+### Macro
+def Macro: Flags
+Is this symbol markes as a macro. An inline method containing toplevel splices
+
+### ModuleClass
+def ModuleClass: Flags
+Is this symbol a module class
+
+### Mutable
+def Mutable: Flags
+Is this symbol a `var` (when used on a ValDef)
+
+### Object
+def Object: Flags
+Is this symbol an object or its class (used for a ValDef or a ClassDef extends Modifier respectively)
+
+### Override
+def Override: Flags
+Is this symbol `override`
+
+### Package
+def Package: Flags
+Is this symbol a package
+
+### Param
+def Param: Flags
+Is this symbol a parameter
+
+### ParamAccessor
+def ParamAccessor: Flags
+Is this symbol a parameter accessor
+
+### Private
+def Private: Flags
+Is this symbol `private`
+
+### PrivateLocal
+def PrivateLocal: Flags
+Is this symbol labeled private[this]
+
+### Protected
+def Protected: Flags
+Is this symbol `protected`
+
+### Scala2X
+def Scala2X: Flags
+Was this symbol imported from Scala2.x
+
+### Sealed
+def Sealed: Flags
+Is this symbol `sealed`
+
+### StableRealizable
+def StableRealizable: Flags
+Is this symbol member that is assumed to be stable and realizable
+
+### Static
+def Static: Flags
+Is this symbol marked as static. Mapped to static Java member
+
+### Synthetic
+def Synthetic: Flags
+Was this symbol generated by Scala compiler
+
+### Trait
+def Trait: Flags
+Is this symbol a trait
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/FlagsOps/FlagsAPI.md b/tastydoc/documentation/scala/tasty/reflect/FlagsOps/FlagsAPI.md
new file mode 100644
index 000000000000..2b6a11dcd1c2
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/FlagsOps/FlagsAPI.md
@@ -0,0 +1,20 @@
+scala.tasty.reflect.FlagsOps
+# class FlagsAPI
+
+class FlagsAPI
+## Constructors:
+FlagsAPI(self: Flags)
+
+## Concrete Value Members:
+### &
+def &(that: Flags): Flags
+Intersection of the two flag sets
+
+### is
+def is(that: Flags): Boolean
+Is the given flag set a subset of this flag sets
+
+### |
+def |(that: Flags): Flags
+Union of the two flag sets
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/IdOps.md b/tastydoc/documentation/scala/tasty/reflect/IdOps.md
new file mode 100644
index 000000000000..ebc85409f66c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/IdOps.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect
+# trait IdOps
+
+trait IdOps extends Core
+## Concrete Type Members:
+### Id
+final object Id
+### IdAPI
+class IdAPI
diff --git a/tastydoc/documentation/scala/tasty/reflect/IdOps/Id$.md b/tastydoc/documentation/scala/tasty/reflect/IdOps/Id$.md
new file mode 100644
index 000000000000..3e159b5741fd
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/IdOps/Id$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.IdOps
+# object Id
+
+final object Id extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(id: Id)(implicit ctx: Context): Option[String]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/IdOps/IdAPI.md b/tastydoc/documentation/scala/tasty/reflect/IdOps/IdAPI.md
new file mode 100644
index 000000000000..ec709dc5a785
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/IdOps/IdAPI.md
@@ -0,0 +1,16 @@
+scala.tasty.reflect.IdOps
+# class IdAPI
+
+class IdAPI
+## Constructors:
+IdAPI(id: Id)
+
+## Concrete Value Members:
+### name
+def name(implicit ctx: Context): String
+Name of the identifier
+
+### pos
+def pos(implicit ctx: Context): Position
+Position in the source code
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps.md b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps.md
new file mode 100644
index 000000000000..16eb19a3851e
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect
+# trait ImportSelectorOps
+
+trait ImportSelectorOps extends Core
+## Concrete Type Members:
+### OmitSelector
+final object OmitSelector
+### RenameSelector
+final object RenameSelector
+### SimpleSelector
+final object SimpleSelector
+### OmitSelectorAPI
+class OmitSelectorAPI
+### RenameSelectorAPI
+class RenameSelectorAPI
+### SimpleSelectorAPI
+class SimpleSelectorAPI
diff --git a/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/OmitSelector$.md b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/OmitSelector$.md
new file mode 100644
index 000000000000..12818c22c0de
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/OmitSelector$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.ImportSelectorOps
+# object OmitSelector
+
+final object OmitSelector extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(importSelector: ImportSelector)(implicit ctx: Context): Option[Id]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/OmitSelectorAPI.md b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/OmitSelectorAPI.md
new file mode 100644
index 000000000000..102cb1cb5fa5
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/OmitSelectorAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.ImportSelectorOps
+# class OmitSelectorAPI
+
+class OmitSelectorAPI
+## Constructors:
+OmitSelectorAPI(self: OmitSelector)
+
+## Concrete Value Members:
+### omitted
+def omitted(implicit ctx: Context): Id
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/RenameSelector$.md b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/RenameSelector$.md
new file mode 100644
index 000000000000..1b604021efda
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/RenameSelector$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.ImportSelectorOps
+# object RenameSelector
+
+final object RenameSelector extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(importSelector: ImportSelector)(implicit ctx: Context): Option[(Id, Id)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/RenameSelectorAPI.md b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/RenameSelectorAPI.md
new file mode 100644
index 000000000000..1a5d884b23e4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/RenameSelectorAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.ImportSelectorOps
+# class RenameSelectorAPI
+
+class RenameSelectorAPI
+## Constructors:
+RenameSelectorAPI(self: RenameSelector)
+
+## Concrete Value Members:
+### from
+def from(implicit ctx: Context): Id
+
+### to
+def to(implicit ctx: Context): Id
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/SimpleSelector$.md b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/SimpleSelector$.md
new file mode 100644
index 000000000000..02ffd7dd4d8d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/SimpleSelector$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.ImportSelectorOps
+# object SimpleSelector
+
+final object SimpleSelector extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(importSelector: ImportSelector)(implicit ctx: Context): Option[Id]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/SimpleSelectorAPI.md b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/SimpleSelectorAPI.md
new file mode 100644
index 000000000000..e53eadf983e3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ImportSelectorOps/SimpleSelectorAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.ImportSelectorOps
+# class SimpleSelectorAPI
+
+class SimpleSelectorAPI
+## Constructors:
+SimpleSelectorAPI(self: SimpleSelector)
+
+## Concrete Value Members:
+### selection
+def selection(implicit ctx: Context): Id
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Kernel.md b/tastydoc/documentation/scala/tasty/reflect/Kernel.md
new file mode 100644
index 000000000000..1cc12db7e22e
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Kernel.md
@@ -0,0 +1,2419 @@
+scala.tasty.reflect
+# trait Kernel
+
+trait Kernel
+Tasty reflect abstract types
+```none```
++- Tree -+- PackageClause
+ +- Import
+ +- Statement -+- Definition --+- PackageDef
+ | | +- ClassDef
+ | | +- TypeDef
+ | | +- DefDef
+ | | +- ValDef
+ | |
+ | +- Term --------+- Ref -+- Ident
+ | | +- Select
+ | |
+ | +- Literal
+ | +- This
+ | +- New
+ | +- NamedArg
+ | +- Apply
+ | +- TypeApply
+ | +- Super
+ | +- Typed
+ | +- Assign
+ | +- Block
+ | +- Lambda
+ | +- If
+ | +- Match
+ | +- ImpliedMatch
+ | +- Try
+ | +- Return
+ | +- Repeated
+ | +- Inlined
+ | +- SelectOuter
+ | +- While
+ |
+ |
+ +- TypeTree ----+- Inferred
+ | +- TypeIdent
+ | +- TypeSelect
+ | +- Projection
+ | +- Singleton
+ | +- Refined
+ | +- Applied
+ | +- Annotated
+ | +- MatchTypeTree
+ | +- ByName
+ | +- LambdaTypeTree
+ | +- TypeBind
+ | +- TypeBlock
+ |
+ +- TypeBoundsTree
+ +- WildcardTypeTree
+ +- CaseDef
+ +- TypeCaseDef
++- Pattern --+- Value
+ +- Bind
+ +- Unapply
+ +- Alternatives
+ +- TypeTest
+ +- WildcardPattern
+ +- NoPrefix
++- TypeOrBounds -+- TypeBounds
+ |
+ +- Type -------+- ConstantType
+ +- SymRef
+ +- TermRef
+ +- TypeRef
+ +- SuperType
+ +- Refinement
+ +- AppliedType
+ +- AnnotatedType
+ +- AndType
+ +- OrType
+ +- MatchType
+ +- ByNameType
+ +- ParamRef
+ +- ThisType
+ +- RecursiveThis
+ +- RecursiveType
+ +- LambdaType[ParamInfo <: TypeOrBounds] -+- MethodType
+ +- PolyType
+ +- TypeLambda
++- ImportSelector -+- SimpleSelector
+ +- RenameSelector
+ +- OmitSelector
++- Id
++- Signature
++- Position
++- Comment
++- Constant
++- Symbol --+- PackageDefSymbol
+ |
+ +- TypeSymbol -+- ClassDefSymbol
+ | +- TypeDefSymbol
+ | +- TypeBindSymbol
+ |
+ +- TermSymbol -+- DefDefSymbol
+ | +- ValDefSymbol
+ | +- BindSymbol
+ |
+ +- NoSymbol
++- Flags
+```
+```
+
+## Concrete Type Members:
+### Alternatives
+type Alternatives: Nothing <: Pattern
+Pattern representing `X | Y | ...` alternatives.
+
+
+### AndType
+type AndType: Nothing <: Type
+Intersection type `T & U`
+
+
+### Annotated
+type Annotated: Nothing <: TypeTree
+Type tree representing an annotated type
+
+
+### AnnotatedType
+type AnnotatedType: Nothing <: Type
+A type with an anottation `T @foo`
+
+
+### Applied
+type Applied: Nothing <: TypeTree
+Type tree representing a type application
+
+
+### AppliedType
+type AppliedType: Nothing <: Type
+A higher kinded type applied to some types `T[U]`
+
+
+### Apply
+type Apply: Nothing <: Term
+Tree an application of arguments. It represents a single list of arguments, multiple argument lists will have nested `Apply`s
+
+
+### Assign
+type Assign: Nothing <: Term
+Tree representing an assignment `x = y` in the source code
+
+
+### Bind
+type Bind: Nothing <: Pattern
+Pattern representing a `_ @ _` binding.
+
+
+### BindSymbol
+type BindSymbol: Nothing <: TermSymbol
+Symbol representing a bind definition.
+
+
+### Block
+type Block: Nothing <: Term
+Tree representing a block `{ ... }` in the source code
+
+
+### ByName
+type ByName: Nothing <: TypeTree
+Type tree representing a by name parameter
+
+
+### ByNameType
+type ByNameType: Nothing <: Type
+Type of a by by name parameter
+
+
+### CaseDef
+type CaseDef: Nothing <: Tree
+Branch of a pattern match or catch clause
+
+
+### ClassDef
+type ClassDef: Nothing <: Definition
+Tree representing a class definition. This includes annonymus class definitions and the class of a module object
+
+
+### ClassDefSymbol
+type ClassDefSymbol: Nothing <: TypeSymbol
+Symbol of a class definition. This includes anonymous class definitions and the class of a module object.
+
+
+### Comment
+type Comment: Nothing <: AnyRef
+Comment
+
+
+### Constant
+type Constant: Nothing <: AnyRef
+Constant value represented as the constant itself
+
+
+### ConstantType
+type ConstantType: Nothing <: Type
+A singleton type representing a known constant value
+
+
+### Context
+type Context: Nothing <: AnyRef
+Compilation context
+
+
+### DefDef
+type DefDef: Nothing <: Definition
+Tree representing a method definition in the source code
+
+
+### DefDefSymbol
+type DefDefSymbol: Nothing <: TermSymbol
+Symbol representing a method definition.
+
+
+### Definition
+type Definition: Nothing <: Statement
+Tree representing a definition in the source code. It can be `PackageDef`, `ClassDef`, `TypeDef`, `DefDef` or `ValDef`
+
+
+### Flags
+type Flags: Nothing <: Any
+FlagSet of a Symbol
+
+
+### Id
+type Id: Nothing <: AnyRef
+Untyped identifier
+
+
+### Ident
+type Ident: Nothing <: Ref
+Tree representing a reference to definition with a given name
+
+
+### If
+type If: Nothing <: Term
+Tree representing an if/then/else `if (...) ... else ...` in the source code
+
+
+### ImpliedMatch
+type ImpliedMatch: Nothing <: Term
+Tree representing a pattern match `delegate match { ... }` in the source code
+
+
+### Import
+type Import: Nothing <: Statement
+Tree representing an import in the source code
+
+
+### ImportSelector
+type ImportSelector: Nothing <: AnyRef
+Import selectors:
+* SimpleSelector: `.bar` in `import foo.bar`
+* RenameSelector: `.{bar => baz}` in `import foo.{bar => baz}`
+* OmitSelector: `.{bar => _}` in `import foo.{bar => _}`
+
+
+### Inferred
+type Inferred: Nothing <: TypeTree
+Type tree representing an inferred type
+
+
+### Inlined
+type Inlined: Nothing <: Term
+Tree representing the scope of an inlined tree
+
+
+### Lambda
+type Lambda: Nothing <: Term
+Tree representing a lambda `(...) => ...` in the source code
+
+
+### LambdaType
+type LambdaType: Nothing <: [ParamInfo >: scala.Nothing <: scala.Any] => Kernel.this.Type
+Common abstraction for lambda types (MethodType, PolyType and TypeLambda).
+
+
+### LambdaTypeTree
+type LambdaTypeTree: Nothing <: TypeTree
+Type tree representing a lambda abstraction type
+
+
+### Literal
+type Literal: Nothing <: Term
+Tree representing a literal value in the source code
+
+
+### Match
+type Match: Nothing <: Term
+Tree representing a pattern match `x match { ... }` in the source code
+
+
+### MatchType
+type MatchType: Nothing <: Type
+Type match `T match { case U => ... }`
+
+
+### MatchTypeTree
+type MatchTypeTree: Nothing <: TypeTree
+Type tree representing a type match
+
+
+### MethodType
+type MethodType: Nothing <: LambdaType[Type]
+Type of the definition of a method taking a single list of parameters. It's return type may be a MethodType.
+
+
+### NamedArg
+type NamedArg: Nothing <: Term
+Tree representing an argument passed with an explicit name. Such as `arg1 = x` in `foo(arg1 = x)`
+
+
+### New
+type New: Nothing <: Term
+Tree representing `new` in the source code
+
+
+### NoPrefix
+type NoPrefix: Nothing <: TypeOrBounds
+NoPrefix for a type selection
+
+
+### NoSymbol
+type NoSymbol: Nothing <: Symbol
+No symbol available.
+
+
+### OmitSelector
+type OmitSelector: Nothing <: ImportSelector
+
+### OrType
+type OrType: Nothing <: Type
+Union type `T | U`
+
+
+### PackageClause
+type PackageClause: Nothing <: Tree
+Tree representing a pacakage clause in the source code
+
+
+### PackageDef
+type PackageDef: Nothing <: Definition
+Tree representing a package definition. This includes definitions in all source files
+
+
+### PackageDefSymbol
+type PackageDefSymbol: Nothing <: Symbol
+Symbol of a package definition
+
+
+### ParamRef
+type ParamRef: Nothing <: Type
+Type of a parameter reference
+
+
+### Pattern
+type Pattern: Nothing <: AnyRef
+Pattern tree of the pattern part of a CaseDef
+
+
+### PolyType
+type PolyType: Nothing <: LambdaType[TypeBounds]
+Type of the definition of a method taking a list of type parameters. It's return type may be a MethodType.
+
+
+### Position
+type Position: Nothing <: AnyRef
+Position in a source file
+
+
+### Projection
+type Projection: Nothing <: TypeTree
+Type tree representing a selection of definition with a given name on a given type prefix
+
+
+### RecursiveThis
+type RecursiveThis: Nothing <: Type
+A type that is recursively defined `this`
+
+
+### RecursiveType
+type RecursiveType: Nothing <: Type
+A type that is recursively defined
+
+
+### Ref
+type Ref: Nothing <: Term
+Tree representing a reference to definition
+
+
+### Refined
+type Refined: Nothing <: TypeTree
+Type tree representing a type refinement
+
+
+### Refinement
+type Refinement: Nothing <: Type
+A type with a type refinement `T { type U }`
+
+
+### RenameSelector
+type RenameSelector: Nothing <: ImportSelector
+
+### Repeated
+type Repeated: Nothing <: Term
+Tree representing a variable argument list in the source code
+
+
+### Return
+type Return: Nothing <: Term
+Tree representing a `return` in the source code
+
+
+### Select
+type Select: Nothing <: Ref
+Tree representing a selection of definition with a given name on a given prefix
+
+
+### SelectOuter
+type SelectOuter: Nothing <: Term
+Tree representing a selection of definition with a given name on a given prefix and number of nested scopes of inlined trees
+
+
+### Settings
+type Settings: Nothing <: AnyRef
+Settings
+
+
+### Signature
+type Signature: Nothing <: AnyRef
+JVM signature of a method
+
+
+### SimpleSelector
+type SimpleSelector: Nothing <: ImportSelector
+
+### Singleton
+type Singleton: Nothing <: TypeTree
+Type tree representing a singleton type
+
+
+### SourceFile
+type SourceFile: Nothing <: AnyRef
+Scala source file
+
+
+### Statement
+type Statement: Nothing <: Tree
+Tree representing a statement in the source code
+
+
+### Super
+type Super: Nothing <: Term
+Tree representing `super` in the source code
+
+
+### SuperType
+type SuperType: Nothing <: Type
+Type of a `super` refernce
+
+
+### SymRef
+type SymRef: Nothing <: Type
+Type of a reference to a symbol
+
+
+### Symbol
+type Symbol: Nothing <: AnyRef
+Symbol of a definition.
+Then can be compared with == to know if the definition is the same.
+
+
+### Term
+type Term: Nothing <: Statement
+Tree representing an expression in the source code
+
+
+### TermRef
+type TermRef: Nothing <: Type
+Type of a reference to a term
+
+
+### TermSymbol
+type TermSymbol: Nothing <: Symbol
+
+### This
+type This: Nothing <: Term
+Tree representing `this` in the source code
+
+
+### ThisType
+type ThisType: Nothing <: Type
+Type of `this`
+
+
+### Tree
+type Tree: Nothing <: AnyRef
+Tree representing code written in the source
+
+
+### Try
+type Try: Nothing <: Term
+Tree representing a tyr catch `try x catch { ... } finally { ... }` in the source code
+
+
+### Type
+type Type: Nothing <: TypeOrBounds
+A type
+
+
+### TypeApply
+type TypeApply: Nothing <: Term
+Tree an application of type arguments
+
+
+### TypeBind
+type TypeBind: Nothing <: TypeTree
+Type tree representing a type binding
+
+
+### TypeBindSymbol
+type TypeBindSymbol: Nothing <: TypeSymbol
+Symbol representing a bind definition.
+
+
+### TypeBlock
+type TypeBlock: Nothing <: TypeTree
+Type tree within a block with aliases `{ type U1 = ... ; T[U1, U2] }`
+
+
+### TypeBounds
+type TypeBounds: Nothing <: TypeOrBounds
+Type bounds
+
+
+### TypeBoundsTree
+type TypeBoundsTree: Nothing <: Tree
+Type tree representing a type bound written in the source
+
+
+### TypeCaseDef
+type TypeCaseDef: Nothing <: Tree
+Branch of a type pattern match
+
+
+### TypeDef
+type TypeDef: Nothing <: Definition
+Tree representing a type (paramter or member) definition in the source code
+
+
+### TypeDefSymbol
+type TypeDefSymbol: Nothing <: TypeSymbol
+Symbol of a type (parameter or member) definition.
+
+
+### TypeIdent
+type TypeIdent: Nothing <: TypeTree
+Type tree representing a reference to definition with a given name
+
+
+### TypeLambda
+type TypeLambda: Nothing <: LambdaType[TypeBounds]
+Type of the definition of a type lambda taking a list of type parameters. It's return type may be a TypeLambda.
+
+
+### TypeOrBounds
+type TypeOrBounds: Nothing <: AnyRef
+Type or bounds
+
+
+### TypeRef
+type TypeRef: Nothing <: Type
+Type of a reference to a type
+
+
+### TypeSelect
+type TypeSelect: Nothing <: TypeTree
+Type tree representing a selection of definition with a given name on a given term prefix
+
+
+### TypeSymbol
+type TypeSymbol: Nothing <: Symbol
+
+### TypeTest
+type TypeTest: Nothing <: Pattern
+Pattern representing a `x: Y` type test.
+
+
+### TypeTree
+type TypeTree: Nothing <: Tree
+Type tree representing a type written in the source
+
+
+### Typed
+type Typed: Nothing <: Term
+Tree representing a type ascription `x: T` in the source code
+
+
+### Unapply
+type Unapply: Nothing <: Pattern
+Pattern representing a `Xyz(...)` unapply.
+
+
+### ValDef
+type ValDef: Nothing <: Definition
+Tree representing a value definition in the source code This inclues `val`, `lazy val`, `var`, `object` and parameter definitions.
+
+
+### ValDefSymbol
+type ValDefSymbol: Nothing <: TermSymbol
+Symbol representing a value definition. This includes `val`, `lazy val`, `var`, `object` and parameter definitions.
+
+
+### Value
+type Value: Nothing <: Pattern
+Pattern representing a value. This includes `1`, ```x``` and `_`
+
+
+### While
+type While: Nothing <: Term
+Tree representing a while loop
+
+
+### WildcardPattern
+type WildcardPattern: Nothing <: Pattern
+Pattern representing a `_` pattern
+
+
+### WildcardTypeTree
+type WildcardTypeTree: Nothing <: Tree
+Type tree representing wildcard type bounds written in the source.
+The wildcard type `_` (for example in in `List[_]`) will be a type tree that
+represents a type but has `TypeBound`a inside.
+
+
+## Concrete Value Members:
+### AndType_left
+def AndType_left(self: AndType)(implicit ctx: Context): Type
+
+### AndType_right
+def AndType_right(self: AndType)(implicit ctx: Context): Type
+
+### AnnotatedType_annot
+def AnnotatedType_annot(self: AnnotatedType)(implicit ctx: Context): Term
+
+### AnnotatedType_underlying
+def AnnotatedType_underlying(self: AnnotatedType)(implicit ctx: Context): Type
+
+### Annotated_annotation
+def Annotated_annotation(self: Annotated)(implicit ctx: Context): Term
+
+### Annotated_apply
+def Annotated_apply(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated
+
+### Annotated_arg
+def Annotated_arg(self: Annotated)(implicit ctx: Context): TypeTree
+
+### Annotated_copy
+def Annotated_copy(original: Annotated)(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated
+
+### AppliedType_args
+def AppliedType_args(self: AppliedType)(implicit ctx: Context): List[TypeOrBounds]
+
+### AppliedType_tycon
+def AppliedType_tycon(self: AppliedType)(implicit ctx: Context): Type
+
+### Applied_apply
+def Applied_apply(tpt: TypeTree, args: List[Tree])(implicit ctx: Context): Applied
+
+### Applied_args
+def Applied_args(self: Applied)(implicit ctx: Context): List[Tree]
+
+### Applied_copy
+def Applied_copy(original: Applied)(tpt: TypeTree, args: List[Tree])(implicit ctx: Context): Applied
+
+### Applied_tpt
+def Applied_tpt(self: Applied)(implicit ctx: Context): TypeTree
+
+### Apply_apply
+def Apply_apply(fn: Term, args: List[Term])(implicit ctx: Context): Apply
+
+### Apply_args
+def Apply_args(self: Apply)(implicit ctx: Context): List[Term]
+
+### Apply_copy
+def Apply_copy(original: Tree)(fun: Term, args: List[Term])(implicit ctx: Context): Apply
+
+### Apply_fun
+def Apply_fun(self: Apply)(implicit ctx: Context): Term
+
+### Assign_apply
+def Assign_apply(lhs: Term, rhs: Term)(implicit ctx: Context): Assign
+
+### Assign_copy
+def Assign_copy(original: Tree)(lhs: Term, rhs: Term)(implicit ctx: Context): Assign
+
+### Assign_lhs
+def Assign_lhs(self: Assign)(implicit ctx: Context): Term
+
+### Assign_rhs
+def Assign_rhs(self: Assign)(implicit ctx: Context): Term
+
+### BindSymbol_tree
+def BindSymbol_tree(self: BindSymbol)(implicit ctx: Context): Bind
+Bind pattern of this definition
+
+### Block_apply
+def Block_apply(stats: List[Statement], expr: Term)(implicit ctx: Context): Block
+
+### Block_copy
+def Block_copy(original: Tree)(stats: List[Statement], expr: Term)(implicit ctx: Context): Block
+
+### Block_expr
+def Block_expr(self: Block)(implicit ctx: Context): Term
+
+### Block_statements
+def Block_statements(self: Block)(implicit ctx: Context): List[Statement]
+
+### ByNameType_underlying
+def ByNameType_underlying(self: ByNameType)(implicit ctx: Context): Type
+
+### ByName_apply
+def ByName_apply(result: TypeTree)(implicit ctx: Context): ByName
+
+### ByName_copy
+def ByName_copy(original: ByName)(result: TypeTree)(implicit ctx: Context): ByName
+
+### ByName_result
+def ByName_result(self: ByName)(implicit ctx: Context): TypeTree
+
+### CaseDef_guard
+def CaseDef_guard(self: CaseDef)(implicit ctx: Context): Option[Term]
+
+### CaseDef_module_apply
+def CaseDef_module_apply(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef
+
+### CaseDef_module_copy
+def CaseDef_module_copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], body: Term)(implicit ctx: Context): CaseDef
+
+### CaseDef_pattern
+def CaseDef_pattern(self: CaseDef)(implicit ctx: Context): Pattern
+
+### CaseDef_rhs
+def CaseDef_rhs(self: CaseDef)(implicit ctx: Context): Term
+
+### ClassDefSymbol_caseFields
+def ClassDefSymbol_caseFields(self: Symbol)(implicit ctx: Context): List[ValDefSymbol]
+Fields of a case class type -- only the ones declared in primary constructor
+
+### ClassDefSymbol_classMethod
+def ClassDefSymbol_classMethod(self: Symbol)(name: String)(implicit ctx: Context): List[DefDefSymbol]
+Get non-private named methods defined directly inside the class
+
+### ClassDefSymbol_classMethods
+def ClassDefSymbol_classMethods(self: Symbol)(implicit ctx: Context): List[DefDefSymbol]
+Get all non-private methods defined directly inside the class, excluding constructors
+
+### ClassDefSymbol_companionClass
+def ClassDefSymbol_companionClass(self: Symbol)(implicit ctx: Context): Option[ClassDefSymbol]
+The class symbol of the companion module class
+
+### ClassDefSymbol_companionModule
+def ClassDefSymbol_companionModule(self: Symbol)(implicit ctx: Context): Option[ValDefSymbol]
+The symbol of the companion module
+
+### ClassDefSymbol_field
+def ClassDefSymbol_field(self: Symbol)(name: String)(implicit ctx: Context): Option[Symbol]
+Field with the given name directly declared in the class
+
+### ClassDefSymbol_fields
+def ClassDefSymbol_fields(self: Symbol)(implicit ctx: Context): List[Symbol]
+Fields directly declared in the class
+
+### ClassDefSymbol_method
+def ClassDefSymbol_method(self: Symbol)(name: String)(implicit ctx: Context): List[DefDefSymbol]
+Get named non-private methods declared or inherited
+
+### ClassDefSymbol_methods
+def ClassDefSymbol_methods(self: Symbol)(implicit ctx: Context): List[DefDefSymbol]
+Get all non-private methods declared or inherited
+
+### ClassDefSymbol_moduleClass
+def ClassDefSymbol_moduleClass(self: Symbol)(implicit ctx: Context): Option[Symbol]
+The symbol of the class of the companion module
+
+### ClassDefSymbol_of
+def ClassDefSymbol_of(fullName: String)(implicit ctx: Context): ClassDefSymbol
+
+### ClassDefSymbol_tree
+def ClassDefSymbol_tree(self: ClassDefSymbol)(implicit ctx: Context): ClassDef
+ClassDef tree of this definition
+
+### ClassDef_body
+def ClassDef_body(self: ClassDef)(implicit ctx: Context): List[Statement]
+
+### ClassDef_constructor
+def ClassDef_constructor(self: ClassDef)(implicit ctx: Context): DefDef
+
+### ClassDef_copy
+def ClassDef_copy(original: ClassDef)(name: String, constr: DefDef, parents: List[Tree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef
+
+### ClassDef_derived
+def ClassDef_derived(self: ClassDef)(implicit ctx: Context): List[TypeTree]
+
+### ClassDef_parents
+def ClassDef_parents(self: ClassDef)(implicit ctx: Context): List[Tree]
+
+### ClassDef_self
+def ClassDef_self(self: ClassDef)(implicit ctx: Context): Option[ValDef]
+
+### ClassDef_symbol
+def ClassDef_symbol(self: ClassDef)(implicit ctx: Context): ClassDefSymbol
+
+### Comment_expanded
+def Comment_expanded(self: Comment): Option[String]
+
+### Comment_raw
+def Comment_raw(self: Comment): String
+
+### Comment_usecases
+def Comment_usecases(self: Comment): List[(String, Option[DefDef])]
+
+### ConstantType_constant
+def ConstantType_constant(self: ConstantType)(implicit ctx: Context): Constant
+
+### Constant_Boolean_apply
+def Constant_Boolean_apply(x: Boolean): Constant
+
+### Constant_Byte_apply
+def Constant_Byte_apply(x: Byte): Constant
+
+### Constant_Char_apply
+def Constant_Char_apply(x: Char): Constant
+
+### Constant_ClassTag_apply
+def Constant_ClassTag_apply(x: ClassTag[Nothing <: Any]): Constant
+
+### Constant_Double_apply
+def Constant_Double_apply(x: Double): Constant
+
+### Constant_Float_apply
+def Constant_Float_apply(x: Float): Constant
+
+### Constant_Int_apply
+def Constant_Int_apply(x: Int): Constant
+
+### Constant_Long_apply
+def Constant_Long_apply(x: Long): Constant
+
+### Constant_Null_apply
+def Constant_Null_apply(): Constant
+
+### Constant_Short_apply
+def Constant_Short_apply(x: Short): Constant
+
+### Constant_String_apply
+def Constant_String_apply(x: String): Constant
+
+### Constant_Symbol_apply
+def Constant_Symbol_apply(x: Symbol): Constant
+
+### Constant_Unit_apply
+def Constant_Unit_apply(): Constant
+
+### Constant_value
+def Constant_value(const: Constant): Any
+
+### Context_owner
+def Context_owner(self: Context): Symbol
+Returns the owner of the context
+
+### Context_printColors
+def Context_printColors(self: Context): Boolean
+Returns true if the generated strings are allowed to use colors
+
+### Context_source
+def Context_source(self: Context): Path
+Returns the source file being compiled. The path is relative to the current working directory.
+
+### Context_withColors
+def Context_withColors(self: Context): Context
+Returns a new context where printColors is true
+
+### Context_withoutColors
+def Context_withoutColors(self: Context): Context
+Returns a new context where printColors is false
+
+### DefDefSymbol_signature
+def DefDefSymbol_signature(self: DefDefSymbol)(implicit ctx: Context): Signature
+Signature of this definition
+
+### DefDefSymbol_tree
+def DefDefSymbol_tree(self: DefDefSymbol)(implicit ctx: Context): DefDef
+DefDef tree of this definition
+
+### DefDef_apply
+def DefDef_apply(symbol: DefDefSymbol, rhsFn: (List[Type]) => (List[List[Term]]) => Option[Term])(implicit ctx: Context): DefDef
+
+### DefDef_copy
+def DefDef_copy(original: DefDef)(name: String, typeParams: List[TypeDef], paramss: List[List[ValDef]], tpt: TypeTree, rhs: Option[Term])(implicit ctx: Context): DefDef
+
+### DefDef_paramss
+def DefDef_paramss(self: DefDef)(implicit ctx: Context): List[List[ValDef]]
+
+### DefDef_returnTpt
+def DefDef_returnTpt(self: DefDef)(implicit ctx: Context): TypeTree
+
+### DefDef_rhs
+def DefDef_rhs(self: DefDef)(implicit ctx: Context): Option[Term]
+
+### DefDef_symbol
+def DefDef_symbol(self: DefDef)(implicit ctx: Context): DefDefSymbol
+
+### DefDef_typeParams
+def DefDef_typeParams(self: DefDef)(implicit ctx: Context): List[TypeDef]
+
+### Definition_name
+def Definition_name(self: Definition)(implicit ctx: Context): String
+
+### Definitions_AnyClass
+def Definitions_AnyClass: Symbol
+
+### Definitions_AnyRefClass
+def Definitions_AnyRefClass: Symbol
+
+### Definitions_AnyRefType
+def Definitions_AnyRefType: Type
+
+### Definitions_AnyType
+def Definitions_AnyType: Type
+
+### Definitions_AnyValClass
+def Definitions_AnyValClass: Symbol
+
+### Definitions_AnyValType
+def Definitions_AnyValType: Type
+
+### Definitions_ArrayClass
+def Definitions_ArrayClass: Symbol
+
+### Definitions_ArrayModule
+def Definitions_ArrayModule: Symbol
+
+### Definitions_Array_apply
+def Definitions_Array_apply: Symbol
+
+### Definitions_Array_clone
+def Definitions_Array_clone: Symbol
+
+### Definitions_Array_length
+def Definitions_Array_length: Symbol
+
+### Definitions_Array_update
+def Definitions_Array_update: Symbol
+
+### Definitions_BooleanClass
+def Definitions_BooleanClass: Symbol
+
+### Definitions_BooleanType
+def Definitions_BooleanType: Type
+
+### Definitions_ByteClass
+def Definitions_ByteClass: Symbol
+
+### Definitions_ByteType
+def Definitions_ByteType: Type
+
+### Definitions_CharClass
+def Definitions_CharClass: Symbol
+
+### Definitions_CharType
+def Definitions_CharType: Type
+
+### Definitions_ClassClass
+def Definitions_ClassClass: Symbol
+
+### Definitions_DoubleClass
+def Definitions_DoubleClass: Symbol
+
+### Definitions_DoubleType
+def Definitions_DoubleType: Type
+
+### Definitions_EmptyPackageClass
+def Definitions_EmptyPackageClass: Symbol
+
+### Definitions_FloatClass
+def Definitions_FloatClass: Symbol
+
+### Definitions_FloatType
+def Definitions_FloatType: Type
+
+### Definitions_FunctionClass
+def Definitions_FunctionClass(arity: Int, isImplicit: Boolean, isErased: Boolean): Symbol
+
+### Definitions_IntClass
+def Definitions_IntClass: Symbol
+
+### Definitions_IntType
+def Definitions_IntType: Type
+
+### Definitions_InternalQuoted_patternBindHoleAnnot
+def Definitions_InternalQuoted_patternBindHoleAnnot: Symbol
+Symbol of scala.internal.Quoted.patternBindHole
+
+### Definitions_InternalQuoted_patternHole
+def Definitions_InternalQuoted_patternHole: Symbol
+Symbol of scala.internal.Quoted.patternHole
+
+### Definitions_JavaLangPackage
+def Definitions_JavaLangPackage: Symbol
+
+### Definitions_LongClass
+def Definitions_LongClass: Symbol
+
+### Definitions_LongType
+def Definitions_LongType: Type
+
+### Definitions_NoneModule
+def Definitions_NoneModule: Symbol
+
+### Definitions_NothingClass
+def Definitions_NothingClass: Symbol
+
+### Definitions_NothingType
+def Definitions_NothingType: Type
+
+### Definitions_NullClass
+def Definitions_NullClass: Symbol
+
+### Definitions_NullType
+def Definitions_NullType: Type
+
+### Definitions_ObjectClass
+def Definitions_ObjectClass: Symbol
+
+### Definitions_ObjectType
+def Definitions_ObjectType: Type
+
+### Definitions_OptionClass
+def Definitions_OptionClass: Symbol
+
+### Definitions_PredefModule
+def Definitions_PredefModule: Symbol
+
+### Definitions_ProductClass
+def Definitions_ProductClass: Symbol
+
+### Definitions_RepeatedParamClass
+def Definitions_RepeatedParamClass: ClassDefSymbol
+
+### Definitions_RootClass
+def Definitions_RootClass: Symbol
+
+### Definitions_RootPackage
+def Definitions_RootPackage: Symbol
+
+### Definitions_ScalaPackage
+def Definitions_ScalaPackage: Symbol
+
+### Definitions_ScalaPackageClass
+def Definitions_ScalaPackageClass: Symbol
+
+### Definitions_ShortClass
+def Definitions_ShortClass: Symbol
+
+### Definitions_ShortType
+def Definitions_ShortType: Type
+
+### Definitions_SomeModule
+def Definitions_SomeModule: Symbol
+
+### Definitions_StringClass
+def Definitions_StringClass: Symbol
+
+### Definitions_StringType
+def Definitions_StringType: Type
+
+### Definitions_TupleClass
+def Definitions_TupleClass(arity: Int): Symbol
+
+### Definitions_UnitClass
+def Definitions_UnitClass: Symbol
+
+### Definitions_UnitType
+def Definitions_UnitType: Type
+
+### Flags_Abstract
+def Flags_Abstract: Flags
+
+### Flags_Artifact
+def Flags_Artifact: Flags
+
+### Flags_Case
+def Flags_Case: Flags
+
+### Flags_CaseAcessor
+def Flags_CaseAcessor: Flags
+
+### Flags_Contravariant
+def Flags_Contravariant: Flags
+
+### Flags_Covariant
+def Flags_Covariant: Flags
+
+### Flags_DefaultParameterized
+def Flags_DefaultParameterized: Flags
+
+### Flags_EmptyFlags
+def Flags_EmptyFlags: Flags
+
+### Flags_Enum
+def Flags_Enum: Flags
+
+### Flags_Erased
+def Flags_Erased: Flags
+
+### Flags_FieldAccessor
+def Flags_FieldAccessor: Flags
+
+### Flags_Final
+def Flags_Final: Flags
+
+### Flags_Given
+def Flags_Given: Flags
+
+### Flags_Implicit
+def Flags_Implicit: Flags
+
+### Flags_Implied
+def Flags_Implied: Flags
+
+### Flags_Inline
+def Flags_Inline: Flags
+
+### Flags_JavaDefined
+def Flags_JavaDefined: Flags
+
+### Flags_Lazy
+def Flags_Lazy: Flags
+
+### Flags_Local
+def Flags_Local: Flags
+
+### Flags_Macro
+def Flags_Macro: Flags
+
+### Flags_ModuleClass
+def Flags_ModuleClass: Flags
+
+### Flags_Mutable
+def Flags_Mutable: Flags
+
+### Flags_Object
+def Flags_Object: Flags
+
+### Flags_Override
+def Flags_Override: Flags
+
+### Flags_Package
+def Flags_Package: Flags
+
+### Flags_Param
+def Flags_Param: Flags
+
+### Flags_ParamAccessor
+def Flags_ParamAccessor: Flags
+
+### Flags_Private
+def Flags_Private: Flags
+
+### Flags_PrivateLocal
+def Flags_PrivateLocal: Flags
+
+### Flags_Protected
+def Flags_Protected: Flags
+
+### Flags_Scala2X
+def Flags_Scala2X: Flags
+
+### Flags_Sealed
+def Flags_Sealed: Flags
+
+### Flags_StableRealizable
+def Flags_StableRealizable: Flags
+
+### Flags_Static
+def Flags_Static: Flags
+
+### Flags_Synthetic
+def Flags_Synthetic: Flags
+
+### Flags_Trait
+def Flags_Trait: Flags
+
+### Flags_and
+def Flags_and(self: Flags)(that: Flags): Flags
+Intersection of the two flag sets
+
+### Flags_is
+def Flags_is(self: Flags)(that: Flags): Boolean
+Is the given flag set a subset of this flag sets
+
+### Flags_or
+def Flags_or(self: Flags)(that: Flags): Flags
+Union of the two flag sets
+
+### Id_name
+def Id_name(self: Id)(implicit ctx: Context): String
+Name of the identifier
+
+### Id_pos
+def Id_pos(self: Id)(implicit ctx: Context): Position
+Position in the source code
+
+### Ident_apply
+def Ident_apply(tmref: TermRef)(implicit ctx: Context): Term
+
+### Ident_copy
+def Ident_copy(original: Tree)(name: String)(implicit ctx: Context): Ident
+
+### Ident_name
+def Ident_name(self: Ident)(implicit ctx: Context): String
+
+### If_apply
+def If_apply(cond: Term, thenp: Term, elsep: Term)(implicit ctx: Context): If
+
+### If_cond
+def If_cond(self: If)(implicit ctx: Context): Term
+
+### If_copy
+def If_copy(original: Tree)(cond: Term, thenp: Term, elsep: Term)(implicit ctx: Context): If
+
+### If_elsep
+def If_elsep(self: If)(implicit ctx: Context): Term
+
+### If_thenp
+def If_thenp(self: If)(implicit ctx: Context): Term
+
+### ImplicitMatch_apply
+def ImplicitMatch_apply(cases: List[CaseDef])(implicit ctx: Context): ImpliedMatch
+
+### ImplicitMatch_cases
+def ImplicitMatch_cases(self: ImpliedMatch)(implicit ctx: Context): List[CaseDef]
+
+### ImplicitMatch_copy
+def ImplicitMatch_copy(original: Tree)(cases: List[CaseDef])(implicit ctx: Context): ImpliedMatch
+
+### Import_apply
+def Import_apply(importImplied: Boolean, expr: Term, selectors: List[ImportSelector])(implicit ctx: Context): Import
+
+### Import_copy
+def Import_copy(original: Import)(importImplied: Boolean, expr: Term, selectors: List[ImportSelector])(implicit ctx: Context): Import
+
+### Import_expr
+def Import_expr(self: Import)(implicit ctx: Context): Term
+
+### Import_implied
+def Import_implied(self: Import): Boolean
+
+### Import_selectors
+def Import_selectors(self: Import)(implicit ctx: Context): List[ImportSelector]
+
+### Inferred_apply
+def Inferred_apply(tpe: Type)(implicit ctx: Context): Inferred
+
+### Inlined_apply
+def Inlined_apply(call: Option[Tree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined
+
+### Inlined_bindings
+def Inlined_bindings(self: Inlined)(implicit ctx: Context): List[Definition]
+
+### Inlined_body
+def Inlined_body(self: Inlined)(implicit ctx: Context): Term
+
+### Inlined_call
+def Inlined_call(self: Inlined)(implicit ctx: Context): Option[Tree]
+
+### Inlined_copy
+def Inlined_copy(original: Tree)(call: Option[Tree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined
+
+### Lambda_apply
+def Lambda_apply(meth: Term, tpt: Option[TypeTree])(implicit ctx: Context): Lambda
+
+### Lambda_copy
+def Lambda_copy(original: Tree)(meth: Tree, tpt: Option[TypeTree])(implicit ctx: Context): Lambda
+
+### Lambda_meth
+def Lambda_meth(self: Lambda)(implicit ctx: Context): Term
+
+### Lambda_tptOpt
+def Lambda_tptOpt(self: Lambda)(implicit ctx: Context): Option[TypeTree]
+
+### Lambdaapply
+def Lambdaapply(tparams: List[TypeDef], body: Tree)(implicit ctx: Context): LambdaTypeTree
+
+### Lambdabody
+def Lambdabody(self: LambdaTypeTree)(implicit ctx: Context): Tree
+
+### Lambdacopy
+def Lambdacopy(original: LambdaTypeTree)(tparams: List[TypeDef], body: Tree)(implicit ctx: Context): LambdaTypeTree
+
+### Lambdatparams
+def Lambdatparams(self: LambdaTypeTree)(implicit ctx: Context): List[TypeDef]
+
+### Literal_apply
+def Literal_apply(constant: Constant)(implicit ctx: Context): Literal
+
+### Literal_constant
+def Literal_constant(self: Literal)(implicit ctx: Context): Constant
+
+### Literal_copy
+def Literal_copy(original: Tree)(constant: Constant)(implicit ctx: Context): Literal
+
+### MatchTypeTree_apply
+def MatchTypeTree_apply(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchTypeTree
+
+### MatchTypeTree_bound
+def MatchTypeTree_bound(self: MatchTypeTree)(implicit ctx: Context): Option[TypeTree]
+
+### MatchTypeTree_cases
+def MatchTypeTree_cases(self: MatchTypeTree)(implicit ctx: Context): List[TypeCaseDef]
+
+### MatchTypeTree_copy
+def MatchTypeTree_copy(original: MatchTypeTree)(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchTypeTree
+
+### MatchTypeTree_selector
+def MatchTypeTree_selector(self: MatchTypeTree)(implicit ctx: Context): TypeTree
+
+### MatchType_bound
+def MatchType_bound(self: MatchType)(implicit ctx: Context): Type
+
+### MatchType_cases
+def MatchType_cases(self: MatchType)(implicit ctx: Context): List[Type]
+
+### MatchType_scrutinee
+def MatchType_scrutinee(self: MatchType)(implicit ctx: Context): Type
+
+### Match_apply
+def Match_apply(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match
+
+### Match_cases
+def Match_cases(self: Match)(implicit ctx: Context): List[CaseDef]
+
+### Match_copy
+def Match_copy(original: Tree)(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match
+
+### Match_scrutinee
+def Match_scrutinee(self: Match)(implicit ctx: Context): Term
+
+### MethodType_isErased
+def MethodType_isErased(self: MethodType): Boolean
+
+### MethodType_isImplicit
+def MethodType_isImplicit(self: MethodType): Boolean
+
+### MethodType_paramNames
+def MethodType_paramNames(self: MethodType)(implicit ctx: Context): List[String]
+
+### MethodType_paramTypes
+def MethodType_paramTypes(self: MethodType)(implicit ctx: Context): List[Type]
+
+### MethodType_resType
+def MethodType_resType(self: MethodType)(implicit ctx: Context): Type
+
+### NamedArg_apply
+def NamedArg_apply(name: String, arg: Term)(implicit ctx: Context): NamedArg
+
+### NamedArg_copy
+def NamedArg_copy(tree: NamedArg)(name: String, arg: Term)(implicit ctx: Context): NamedArg
+
+### NamedArg_name
+def NamedArg_name(self: NamedArg)(implicit ctx: Context): String
+
+### NamedArg_value
+def NamedArg_value(self: NamedArg)(implicit ctx: Context): Term
+
+### New_apply
+def New_apply(tpt: TypeTree)(implicit ctx: Context): New
+
+### New_copy
+def New_copy(original: Tree)(tpt: TypeTree)(implicit ctx: Context): New
+
+### New_tpt
+def New_tpt(self: New)(implicit ctx: Context): TypeTree
+
+### OrType_left
+def OrType_left(self: OrType)(implicit ctx: Context): Type
+
+### OrType_right
+def OrType_right(self: OrType)(implicit ctx: Context): Type
+
+### PackageClause_apply
+def PackageClause_apply(pid: Ref, stats: List[Tree])(implicit ctx: Context): PackageClause
+
+### PackageClause_copy
+def PackageClause_copy(original: PackageClause)(pid: Ref, stats: List[Tree])(implicit ctx: Context): PackageClause
+
+### PackageClause_pid
+def PackageClause_pid(self: PackageClause)(implicit ctx: Context): Ref
+
+### PackageClause_stats
+def PackageClause_stats(self: PackageClause)(implicit ctx: Context): List[Tree]
+
+### PackageDefSymbol_tree
+def PackageDefSymbol_tree(self: PackageDefSymbol)(implicit ctx: Context): PackageDef
+
+### PackageDef_members
+def PackageDef_members(self: PackageDef)(implicit ctx: Context): List[Statement]
+
+### PackageDef_owner
+def PackageDef_owner(self: PackageDef)(implicit ctx: Context): PackageDef
+
+### PackageDef_symbol
+def PackageDef_symbol(self: PackageDef)(implicit ctx: Context): PackageDefSymbol
+
+### ParamRef_binder
+def ParamRef_binder(self: ParamRef)(implicit ctx: Context): LambdaType[TypeOrBounds]
+
+### ParamRef_paramNum
+def ParamRef_paramNum(self: ParamRef)(implicit ctx: Context): Int
+
+### Pattern_Alternatives_module_apply
+def Pattern_Alternatives_module_apply(patterns: List[Pattern])(implicit ctx: Context): Alternatives
+
+### Pattern_Alternatives_module_copy
+def Pattern_Alternatives_module_copy(original: Alternatives)(patterns: List[Pattern])(implicit ctx: Context): Alternatives
+
+### Pattern_Alternatives_patterns
+def Pattern_Alternatives_patterns(self: Alternatives)(implicit ctx: Context): List[Pattern]
+
+### Pattern_Bind_module_copy
+def Pattern_Bind_module_copy(original: Bind)(name: String, pattern: Pattern)(implicit ctx: Context): Bind
+
+### Pattern_Bind_name
+def Pattern_Bind_name(self: Bind)(implicit ctx: Context): String
+
+### Pattern_Bind_pattern
+def Pattern_Bind_pattern(self: Bind)(implicit ctx: Context): Pattern
+
+### Pattern_TypeTest_module_apply
+def Pattern_TypeTest_module_apply(tpt: TypeTree)(implicit ctx: Context): TypeTest
+
+### Pattern_TypeTest_module_copy
+def Pattern_TypeTest_module_copy(original: TypeTest)(tpt: TypeTree)(implicit ctx: Context): TypeTest
+
+### Pattern_TypeTest_tpt
+def Pattern_TypeTest_tpt(self: TypeTest)(implicit ctx: Context): TypeTree
+
+### Pattern_Unapply_fun
+def Pattern_Unapply_fun(self: Unapply)(implicit ctx: Context): Term
+
+### Pattern_Unapply_implicits
+def Pattern_Unapply_implicits(self: Unapply)(implicit ctx: Context): List[Term]
+
+### Pattern_Unapply_module_copy
+def Pattern_Unapply_module_copy(original: Unapply)(fun: Term, implicits: List[Term], patterns: List[Pattern])(implicit ctx: Context): Unapply
+
+### Pattern_Unapply_patterns
+def Pattern_Unapply_patterns(self: Unapply)(implicit ctx: Context): List[Pattern]
+
+### Pattern_Value_module_apply
+def Pattern_Value_module_apply(term: Term)(implicit ctx: Context): Value
+
+### Pattern_Value_module_copy
+def Pattern_Value_module_copy(original: Value)(term: Term)(implicit ctx: Context): Value
+
+### Pattern_Value_value
+def Pattern_Value_value(self: Value)(implicit ctx: Context): Term
+
+### Pattern_WildcardPattern_module_apply
+def Pattern_WildcardPattern_module_apply(tpe: TypeOrBounds)(implicit ctx: Context): WildcardPattern
+
+### Pattern_pos
+def Pattern_pos(self: Pattern)(implicit ctx: Context): Position
+
+### Pattern_symbol
+def Pattern_symbol(self: Pattern)(implicit ctx: Context): Symbol
+
+### Pattern_tpe
+def Pattern_tpe(self: Pattern)(implicit ctx: Context): Type
+
+### PolyType_paramBounds
+def PolyType_paramBounds(self: PolyType)(implicit ctx: Context): List[TypeBounds]
+
+### PolyType_paramNames
+def PolyType_paramNames(self: PolyType)(implicit ctx: Context): List[String]
+
+### PolyType_resType
+def PolyType_resType(self: PolyType)(implicit ctx: Context): Type
+
+### Position_end
+def Position_end(self: Position): Int
+The end offset in the source file
+
+### Position_endColumn
+def Position_endColumn(self: Position): Int
+The end column in the source file
+
+### Position_endLine
+def Position_endLine(self: Position): Int
+The end line in the source file
+
+### Position_exists
+def Position_exists(self: Position): Boolean
+Does this position exist
+
+### Position_sourceCode
+def Position_sourceCode(self: Position): String
+Source code within the position
+
+### Position_sourceFile
+def Position_sourceFile(self: Position): SourceFile
+Source file in which this position is located
+
+### Position_start
+def Position_start(self: Position): Int
+The start offset in the source file
+
+### Position_startColumn
+def Position_startColumn(self: Position): Int
+The start column in the source file
+
+### Position_startLine
+def Position_startLine(self: Position): Int
+The start line in the source file
+
+### Projection_copy
+def Projection_copy(original: Projection)(qualifier: TypeTree, name: String)(implicit ctx: Context): Projection
+
+### Projection_name
+def Projection_name(self: Projection)(implicit ctx: Context): String
+
+### Projection_qualifier
+def Projection_qualifier(self: Projection)(implicit ctx: Context): TypeTree
+
+### QuotedExpr_cast
+def QuotedExpr_cast[U](self: Expr[Nothing <: Any])(implicit tp: Type[U], ctx: Context): Expr[U]
+Checked cast to a `quoted.Expr[U]`
+
+### QuotedExpr_seal
+def QuotedExpr_seal(self: Term)(implicit ctx: Context): Expr[Any]
+Convert `Term` to an `quoted.Expr[Any]`
+
+### QuotedExpr_unseal
+def QuotedExpr_unseal(self: Expr[Nothing <: Any])(implicit ctx: Context): Term
+View this expression `quoted.Expr[_]` as a `Term`
+
+### QuotedType_seal
+def QuotedType_seal(self: Type)(implicit ctx: Context): Type[Nothing <: AnyKind]
+Convert `Type` to an `quoted.Type[_]`
+
+### QuotedType_unseal
+def QuotedType_unseal(self: Type[Nothing <: AnyKind])(implicit ctx: Context): TypeTree
+View this expression `quoted.Type[T]` as a `TypeTree`
+
+### RecursiveThis_binder
+def RecursiveThis_binder(self: RecursiveThis)(implicit ctx: Context): RecursiveType
+
+### RecursiveType_underlying
+def RecursiveType_underlying(self: RecursiveType)(implicit ctx: Context): Type
+
+### Ref_apply
+def Ref_apply(sym: Symbol)(implicit ctx: Context): Ref
+
+### Refined_copy
+def Refined_copy(original: Refined)(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined
+
+### Refined_refinements
+def Refined_refinements(self: Refined)(implicit ctx: Context): List[Definition]
+
+### Refined_tpt
+def Refined_tpt(self: Refined)(implicit ctx: Context): TypeTree
+
+### Refinement_info
+def Refinement_info(self: Refinement)(implicit ctx: Context): TypeOrBounds
+
+### Refinement_name
+def Refinement_name(self: Refinement)(implicit ctx: Context): String
+
+### Refinement_parent
+def Refinement_parent(self: Refinement)(implicit ctx: Context): Type
+
+### RenameSelector_from
+def RenameSelector_from(self: RenameSelector)(implicit ctx: Context): Id
+
+### RenameSelector_to
+def RenameSelector_to(self: RenameSelector)(implicit ctx: Context): Id
+
+### Repeated_apply
+def Repeated_apply(elems: List[Term], elemtpt: TypeTree)(implicit ctx: Context): Repeated
+
+### Repeated_copy
+def Repeated_copy(original: Tree)(elems: List[Term], elemtpt: TypeTree)(implicit ctx: Context): Repeated
+
+### Repeated_elems
+def Repeated_elems(self: Repeated)(implicit ctx: Context): List[Term]
+
+### Repeated_elemtpt
+def Repeated_elemtpt(self: Repeated)(implicit ctx: Context): TypeTree
+
+### Return_apply
+def Return_apply(expr: Term)(implicit ctx: Context): Return
+
+### Return_copy
+def Return_copy(original: Tree)(expr: Term)(implicit ctx: Context): Return
+
+### Return_expr
+def Return_expr(self: Return)(implicit ctx: Context): Term
+
+### SelectOuter_apply
+def SelectOuter_apply(qualifier: Term, name: String, levels: Int)(implicit ctx: Context): SelectOuter
+
+### SelectOuter_copy
+def SelectOuter_copy(original: Tree)(qualifier: Term, name: String, levels: Int)(implicit ctx: Context): SelectOuter
+
+### SelectOuter_level
+def SelectOuter_level(self: SelectOuter)(implicit ctx: Context): Int
+
+### SelectOuter_qualifier
+def SelectOuter_qualifier(self: SelectOuter)(implicit ctx: Context): Term
+
+### SelectOuter_tpe
+def SelectOuter_tpe(self: SelectOuter)(implicit ctx: Context): Type
+
+### Select_apply
+def Select_apply(qualifier: Term, symbol: Symbol)(implicit ctx: Context): Select
+
+### Select_copy
+def Select_copy(original: Tree)(qualifier: Term, name: String)(implicit ctx: Context): Select
+
+### Select_name
+def Select_name(self: Select)(implicit ctx: Context): String
+
+### Select_overloaded
+def Select_overloaded(qualifier: Term, name: String, targs: List[Type], args: List[Term])(implicit ctx: Context): Apply
+
+### Select_qualifier
+def Select_qualifier(self: Select)(implicit ctx: Context): Term
+
+### Select_signature
+def Select_signature(self: Select)(implicit ctx: Context): Option[Signature]
+
+### Select_unique
+def Select_unique(qualifier: Term, name: String)(implicit ctx: Context): Select
+
+### Settings_color
+def Settings_color(self: Settings): Boolean
+
+### Signature_paramSigs
+def Signature_paramSigs(self: Signature): List[String]
+The (JVM) erased signatures of the parameters
+
+### Signature_resultSig
+def Signature_resultSig(self: Signature): String
+The (JVM) erased result type
+
+### SimpleSelector_omited
+def SimpleSelector_omited(self: OmitSelector)(implicit ctx: Context): Id
+
+### SimpleSelector_selection
+def SimpleSelector_selection(self: SimpleSelector)(implicit ctx: Context): Id
+
+### Singleton_apply
+def Singleton_apply(ref: Term)(implicit ctx: Context): Singleton
+
+### Singleton_copy
+def Singleton_copy(original: Singleton)(ref: Term)(implicit ctx: Context): Singleton
+
+### Singleton_ref
+def Singleton_ref(self: Singleton)(implicit ctx: Context): Term
+
+### SourceFile_content
+def SourceFile_content(self: SourceFile): String
+Content of a source file
+
+### SourceFile_jpath
+def SourceFile_jpath(self: SourceFile): Path
+Path to a source file
+
+### SuperType_supertpe
+def SuperType_supertpe(self: SuperType)(implicit ctx: Context): Type
+
+### SuperType_thistpe
+def SuperType_thistpe(self: SuperType)(implicit ctx: Context): Type
+
+### Super_apply
+def Super_apply(qual: Term, mix: Option[Id])(implicit ctx: Context): Super
+
+### Super_copy
+def Super_copy(original: Tree)(qual: Term, mix: Option[Id])(implicit ctx: Context): Super
+
+### Super_id
+def Super_id(self: Super)(implicit ctx: Context): Option[Id]
+
+### Super_qualifier
+def Super_qualifier(self: Super)(implicit ctx: Context): Term
+
+### SymRef_qualifier
+def SymRef_qualifier(self: SymRef)(implicit ctx: Context): TypeOrBounds
+
+### Symbol_annots
+def Symbol_annots(self: Symbol)(implicit ctx: Context): List[Term]
+Annotations attached to this symbol
+
+### Symbol_comment
+def Symbol_comment(self: Symbol)(implicit ctx: Context): Option[Comment]
+The comment of the symbol
+
+### Symbol_flags
+def Symbol_flags(self: Symbol)(implicit ctx: Context): Flags
+Flags of this symbol
+
+### Symbol_fullName
+def Symbol_fullName(self: Symbol)(implicit ctx: Context): String
+The full name of this symbol up to the root package.
+
+### Symbol_isAbstractType
+def Symbol_isAbstractType(self: Symbol)(implicit ctx: Context): Boolean
+
+### Symbol_isAliasType
+def Symbol_isAliasType(self: Symbol)(implicit ctx: Context): Boolean
+
+### Symbol_isAnonymousClass
+def Symbol_isAnonymousClass(self: Symbol)(implicit ctx: Context): Boolean
+
+### Symbol_isAnonymousFunction
+def Symbol_isAnonymousFunction(self: Symbol)(implicit ctx: Context): Boolean
+
+### Symbol_isClassConstructor
+def Symbol_isClassConstructor(self: Symbol)(implicit ctx: Context): Boolean
+
+### Symbol_isDefinedInCurrentRun
+def Symbol_isDefinedInCurrentRun(self: Symbol)(implicit ctx: Context): Boolean
+
+### Symbol_isLocalDummy
+def Symbol_isLocalDummy(self: Symbol)(implicit ctx: Context): Boolean
+
+### Symbol_isRefinementClass
+def Symbol_isRefinementClass(self: Symbol)(implicit ctx: Context): Boolean
+
+### Symbol_localContext
+def Symbol_localContext(self: Symbol)(implicit ctx: Context): Context
+
+### Symbol_name
+def Symbol_name(self: Symbol)(implicit ctx: Context): String
+The name of this symbol.
+
+### Symbol_owner
+def Symbol_owner(self: Symbol)(implicit ctx: Context): Symbol
+Owner of this symbol. The owner is the symbol in which this symbol is defined.
+
+### Symbol_pos
+def Symbol_pos(self: Symbol)(implicit ctx: Context): Position
+The position of this symbol
+
+### Symbol_privateWithin
+def Symbol_privateWithin(self: Symbol)(implicit ctx: Context): Option[Type]
+This symbol is private within the resulting type.
+
+### Symbol_protectedWithin
+def Symbol_protectedWithin(self: Symbol)(implicit ctx: Context): Option[Type]
+This symbol is protected within the resulting type.
+
+### TermRef_apply
+def TermRef_apply(qual: TypeOrBounds, name: String)(implicit ctx: Context): TermRef
+
+### TermRef_name
+def TermRef_name(self: TermRef)(implicit ctx: Context): String
+
+### TermRef_qualifier
+def TermRef_qualifier(self: TermRef)(implicit ctx: Context): TypeOrBounds
+
+### Term_pos
+def Term_pos(self: Term)(implicit ctx: Context): Position
+
+### Term_tpe
+def Term_tpe(self: Term)(implicit ctx: Context): Type
+
+### Term_underlying
+def Term_underlying(self: Term)(implicit ctx: Context): Term
+
+### Term_underlyingArgument
+def Term_underlyingArgument(self: Term)(implicit ctx: Context): Term
+
+### ThisType_tref
+def ThisType_tref(self: ThisType)(implicit ctx: Context): Type
+
+### This_apply
+def This_apply(cls: ClassDefSymbol)(implicit ctx: Context): This
+
+### This_copy
+def This_copy(original: Tree)(qual: Option[Id])(implicit ctx: Context): This
+
+### This_id
+def This_id(self: This)(implicit ctx: Context): Option[Id]
+
+### Tree_pos
+def Tree_pos(self: Tree)(implicit ctx: Context): Position
+
+### Tree_symbol
+def Tree_symbol(self: Tree)(implicit ctx: Context): Symbol
+
+### Try_apply
+def Try_apply(expr: Term, cases: List[CaseDef], finalizer: Option[Term])(implicit ctx: Context): Try
+
+### Try_body
+def Try_body(self: Try)(implicit ctx: Context): Term
+
+### Try_cases
+def Try_cases(self: Try)(implicit ctx: Context): List[CaseDef]
+
+### Try_copy
+def Try_copy(original: Tree)(expr: Term, cases: List[CaseDef], finalizer: Option[Term])(implicit ctx: Context): Try
+
+### Try_finalizer
+def Try_finalizer(self: Try)(implicit ctx: Context): Option[Term]
+
+### TypeApply_apply
+def TypeApply_apply(fn: Term, args: List[TypeTree])(implicit ctx: Context): TypeApply
+
+### TypeApply_args
+def TypeApply_args(self: TypeApply)(implicit ctx: Context): List[TypeTree]
+
+### TypeApply_copy
+def TypeApply_copy(original: Tree)(fun: Term, args: List[TypeTree])(implicit ctx: Context): TypeApply
+
+### TypeApply_fun
+def TypeApply_fun(self: TypeApply)(implicit ctx: Context): Term
+
+### TypeBindSymbol_tree
+def TypeBindSymbol_tree(self: TypeBindSymbol)(implicit ctx: Context): TypeBind
+TypeBind pattern of this definition
+
+### TypeBind_body
+def TypeBind_body(self: TypeBind)(implicit ctx: Context): Tree
+
+### TypeBind_copy
+def TypeBind_copy(original: TypeBind)(name: String, tpt: Tree)(implicit ctx: Context): TypeBind
+
+### TypeBind_name
+def TypeBind_name(self: TypeBind)(implicit ctx: Context): String
+
+### TypeBlock_aliases
+def TypeBlock_aliases(self: TypeBlock)(implicit ctx: Context): List[TypeDef]
+
+### TypeBlock_apply
+def TypeBlock_apply(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock
+
+### TypeBlock_copy
+def TypeBlock_copy(original: TypeBlock)(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock
+
+### TypeBlock_tpt
+def TypeBlock_tpt(self: TypeBlock)(implicit ctx: Context): TypeTree
+
+### TypeBoundsTree_hi
+def TypeBoundsTree_hi(self: TypeBoundsTree)(implicit ctx: Context): TypeTree
+
+### TypeBoundsTree_low
+def TypeBoundsTree_low(self: TypeBoundsTree)(implicit ctx: Context): TypeTree
+
+### TypeBoundsTree_tpe
+def TypeBoundsTree_tpe(self: TypeBoundsTree)(implicit ctx: Context): TypeBounds
+
+### TypeBounds_hi
+def TypeBounds_hi(self: TypeBounds)(implicit ctx: Context): Type
+
+### TypeBounds_low
+def TypeBounds_low(self: TypeBounds)(implicit ctx: Context): Type
+
+### TypeCaseDef_module_apply
+def TypeCaseDef_module_apply(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef
+
+### TypeCaseDef_module_copy
+def TypeCaseDef_module_copy(original: TypeCaseDef)(pattern: TypeTree, body: TypeTree)(implicit ctx: Context): TypeCaseDef
+
+### TypeCaseDef_pattern
+def TypeCaseDef_pattern(self: TypeCaseDef)(implicit ctx: Context): TypeTree
+
+### TypeCaseDef_rhs
+def TypeCaseDef_rhs(self: TypeCaseDef)(implicit ctx: Context): TypeTree
+
+### TypeDefSymbol_isTypeParam
+def TypeDefSymbol_isTypeParam(self: TypeDefSymbol)(implicit ctx: Context): Boolean
+
+### TypeDefSymbol_tree
+def TypeDefSymbol_tree(self: TypeDefSymbol)(implicit ctx: Context): TypeDef
+TypeDef tree of this definition
+
+### TypeDef_apply
+def TypeDef_apply(symbol: TypeDefSymbol)(implicit ctx: Context): TypeDef
+
+### TypeDef_copy
+def TypeDef_copy(original: TypeDef)(name: String, rhs: Tree)(implicit ctx: Context): TypeDef
+
+### TypeDef_rhs
+def TypeDef_rhs(self: TypeDef)(implicit ctx: Context): Tree
+
+### TypeDef_symbol
+def TypeDef_symbol(self: TypeDef)(implicit ctx: Context): TypeDefSymbol
+
+### TypeIdent_copy
+def TypeIdent_copy(original: TypeIdent)(name: String)(implicit ctx: Context): TypeIdent
+
+### TypeIdent_name
+def TypeIdent_name(self: TypeIdent)(implicit ctx: Context): String
+
+### TypeLambda_paramBounds
+def TypeLambda_paramBounds(self: TypeLambda)(implicit ctx: Context): List[TypeBounds]
+
+### TypeLambda_paramNames
+def TypeLambda_paramNames(self: TypeLambda)(implicit ctx: Context): List[String]
+
+### TypeLambda_resType
+def TypeLambda_resType(self: TypeLambda)(implicit ctx: Context): Type
+
+### TypeRef_name
+def TypeRef_name(self: TypeRef)(implicit ctx: Context): String
+
+### TypeRef_qualifier
+def TypeRef_qualifier(self: TypeRef)(implicit ctx: Context): TypeOrBounds
+
+### TypeSelect_apply
+def TypeSelect_apply(qualifier: Term, name: String)(implicit ctx: Context): TypeSelect
+
+### TypeSelect_copy
+def TypeSelect_copy(original: TypeSelect)(qualifier: Term, name: String)(implicit ctx: Context): TypeSelect
+
+### TypeSelect_name
+def TypeSelect_name(self: TypeSelect)(implicit ctx: Context): String
+
+### TypeSelect_qualifier
+def TypeSelect_qualifier(self: TypeSelect)(implicit ctx: Context): Term
+
+### TypeTree_pos
+def TypeTree_pos(self: TypeTree)(implicit ctx: Context): Position
+
+### TypeTree_symbol
+def TypeTree_symbol(self: TypeTree)(implicit ctx: Context): Symbol
+
+### TypeTree_tpe
+def TypeTree_tpe(self: TypeTree)(implicit ctx: Context): Type
+
+### Type_$u003C:$u003C
+def Type_$u003C:$u003C(self: Type)(that: Type)(implicit ctx: Context): Boolean
+
+### Type_=:=
+def Type_=:=(self: Type)(that: Type)(implicit ctx: Context): Boolean
+
+### Type_classSymbol
+def Type_classSymbol(self: Type)(implicit ctx: Context): Option[ClassDefSymbol]
+
+### Type_dealias
+def Type_dealias(self: Type)(implicit ctx: Context): Type
+Follow aliases and dereferences LazyRefs, annotated types and instantiated
+TypeVars until type is no longer alias type, annotated type, LazyRef,
+or instantiated type variable.
+
+### Type_derivesFrom
+def Type_derivesFrom(self: Type)(cls: ClassDefSymbol)(implicit ctx: Context): Boolean
+Is this type an instance of a non-bottom subclass of the given class `cls`?
+
+### Type_isDependentFunctionType
+def Type_isDependentFunctionType(self: Type)(implicit ctx: Context): Boolean
+Is this type a dependent function type?
+
+***see*** `Type_isFunctionType`
+
+### Type_isErasedFunctionType
+def Type_isErasedFunctionType(self: Type)(implicit ctx: Context): Boolean
+Is this type an erased function type?
+
+***see*** `Type_isFunctionType`
+
+### Type_isFunctionType
+def Type_isFunctionType(self: Type)(implicit ctx: Context): Boolean
+Is this type a function type?
+
+***return*** true if the dealised type of `self` without refinement is `FunctionN[T1, T2, ..., Tn]`
+
+***Note*** The function
+* returns true for `given Int => Int` and `erased Int => Int`
+* returns false for `List[Int]`, despite that `List[Int] <:< Int => Int`.
+
+
+### Type_isImplicitFunctionType
+def Type_isImplicitFunctionType(self: Type)(implicit ctx: Context): Boolean
+Is this type an implicit function type?
+
+***see*** `Type_isFunctionType`
+
+### Type_isSingleton
+def Type_isSingleton(self: Type)(implicit ctx: Context): Boolean
+
+### Type_memberType
+def Type_memberType(self: Type)(member: Symbol)(implicit ctx: Context): Type
+
+### Type_typeSymbol
+def Type_typeSymbol(self: Type)(implicit ctx: Context): Symbol
+
+### Type_widen
+def Type_widen(self: Type)(implicit ctx: Context): Type
+Widen from singleton type to its underlying non-singleton
+base type by applying one or more `underlying` dereferences,
+Also go from => T to T.
+Identity for all other types. Example:
+class Outer { class C ; val x: C }
+def o: Outer
+.widen = o.C
+
+### Typed_apply
+def Typed_apply(expr: Term, tpt: TypeTree)(implicit ctx: Context): Typed
+
+### Typed_copy
+def Typed_copy(original: Tree)(expr: Term, tpt: TypeTree)(implicit ctx: Context): Typed
+
+### Typed_expr
+def Typed_expr(self: Typed)(implicit ctx: Context): Term
+
+### Typed_tpt
+def Typed_tpt(self: Typed)(implicit ctx: Context): TypeTree
+
+### ValDefSymbol_companionClass
+def ValDefSymbol_companionClass(self: ValDefSymbol)(implicit ctx: Context): Option[ClassDefSymbol]
+
+### ValDefSymbol_moduleClass
+def ValDefSymbol_moduleClass(self: ValDefSymbol)(implicit ctx: Context): Option[ClassDefSymbol]
+The class symbol of the companion module class
+
+### ValDefSymbol_tree
+def ValDefSymbol_tree(self: ValDefSymbol)(implicit ctx: Context): ValDef
+ValDef tree of this definition
+
+### ValDef_apply
+def ValDef_apply(symbol: ValDefSymbol, rhs: Option[Term])(implicit ctx: Context): ValDef
+
+### ValDef_copy
+def ValDef_copy(original: ValDef)(name: String, tpt: TypeTree, rhs: Option[Term])(implicit ctx: Context): ValDef
+
+### ValDef_rhs
+def ValDef_rhs(self: ValDef)(implicit ctx: Context): Option[Term]
+
+### ValDef_symbol
+def ValDef_symbol(self: ValDef)(implicit ctx: Context): ValDefSymbol
+
+### ValDef_tpt
+def ValDef_tpt(self: ValDef)(implicit ctx: Context): TypeTree
+
+### While_apply
+def While_apply(cond: Term, body: Term)(implicit ctx: Context): While
+
+### While_body
+def While_body(self: While)(implicit ctx: Context): Term
+
+### While_cond
+def While_cond(self: While)(implicit ctx: Context): Term
+
+### While_copy
+def While_copy(original: Tree)(cond: Term, body: Term)(implicit ctx: Context): While
+
+### WildcardTypeTree_tpe
+def WildcardTypeTree_tpe(self: WildcardTypeTree)(implicit ctx: Context): TypeOrBounds
+
+### error
+def error(msg: => String, source: SourceFile, start: Int, end: Int)(implicit ctx: Context): Unit
+Report a compilation error with the given message at the given position range
+
+### error
+def error(msg: => String, pos: Position)(implicit ctx: Context): Unit
+Report a compilation error with the given message at the given position
+
+### matchAndType
+def matchAndType(tpe: TypeOrBounds)(implicit ctx: Context): Option[AndType]
+
+### matchAnnotated
+def matchAnnotated(tree: Tree)(implicit ctx: Context): Option[Annotated]
+
+### matchAnnotatedType
+def matchAnnotatedType(tpe: TypeOrBounds)(implicit ctx: Context): Option[AnnotatedType]
+
+### matchApplied
+def matchApplied(tree: Tree)(implicit ctx: Context): Option[Applied]
+
+### matchAppliedType
+def matchAppliedType(tpe: TypeOrBounds)(implicit ctx: Context): Option[AppliedType]
+
+### matchApply
+def matchApply(tree: Tree)(implicit ctx: Context): Option[Apply]
+
+### matchAssign
+def matchAssign(tree: Tree)(implicit ctx: Context): Option[Assign]
+
+### matchBindSymbol
+def matchBindSymbol(symbol: Symbol)(implicit ctx: Context): Option[BindSymbol]
+
+### matchBlock
+def matchBlock(tree: Tree)(implicit ctx: Context): Option[Block]
+
+### matchByName
+def matchByName(tree: Tree)(implicit ctx: Context): Option[ByName]
+
+### matchByNameType
+def matchByNameType(tpe: TypeOrBounds)(implicit ctx: Context): Option[ByNameType]
+
+### matchCaseDef
+def matchCaseDef(tree: Tree)(implicit ctx: Context): Option[CaseDef]
+
+### matchClassDef
+def matchClassDef(tree: Tree)(implicit ctx: Context): Option[ClassDef]
+
+### matchClassDefSymbol
+def matchClassDefSymbol(symbol: Symbol)(implicit ctx: Context): Option[ClassDefSymbol]
+
+### matchConstantType
+def matchConstantType(tpe: TypeOrBounds)(implicit ctx: Context): Option[ConstantType]
+
+### matchConstant_Boolean
+def matchConstant_Boolean(constant: Constant): Option[Boolean]
+
+### matchConstant_Byte
+def matchConstant_Byte(constant: Constant): Option[Byte]
+
+### matchConstant_Char
+def matchConstant_Char(constant: Constant): Option[Char]
+
+### matchConstant_ClassTag
+def matchConstant_ClassTag(constant: Constant): Option[Type]
+
+### matchConstant_Double
+def matchConstant_Double(constant: Constant): Option[Double]
+
+### matchConstant_Float
+def matchConstant_Float(constant: Constant): Option[Float]
+
+### matchConstant_Int
+def matchConstant_Int(constant: Constant): Option[Int]
+
+### matchConstant_Long
+def matchConstant_Long(constant: Constant): Option[Long]
+
+### matchConstant_Null
+def matchConstant_Null(constant: Constant): Boolean
+
+### matchConstant_Short
+def matchConstant_Short(constant: Constant): Option[Short]
+
+### matchConstant_String
+def matchConstant_String(constant: Constant): Option[String]
+
+### matchConstant_Symbol
+def matchConstant_Symbol(constant: Constant): Option[Symbol]
+
+### matchConstant_Unit
+def matchConstant_Unit(constant: Constant): Boolean
+
+### matchDefDef
+def matchDefDef(tree: Tree)(implicit ctx: Context): Option[DefDef]
+
+### matchDefDefSymbol
+def matchDefDefSymbol(symbol: Symbol)(implicit ctx: Context): Option[DefDefSymbol]
+
+### matchDefinition
+def matchDefinition(tree: Tree)(implicit ctx: Context): Option[Definition]
+
+### matchIdent
+def matchIdent(tree: Tree)(implicit ctx: Context): Option[Ident]
+
+### matchIf
+def matchIf(tree: Tree)(implicit ctx: Context): Option[If]
+
+### matchImplicitMatch
+def matchImplicitMatch(tree: Tree)(implicit ctx: Context): Option[ImpliedMatch]
+
+### matchImport
+def matchImport(tree: Tree)(implicit ctx: Context): Option[Import]
+
+### matchInferred
+def matchInferred(tree: Tree)(implicit ctx: Context): Option[Inferred]
+
+### matchInlined
+def matchInlined(tree: Tree)(implicit ctx: Context): Option[Inlined]
+
+### matchLambda
+def matchLambda(tree: Tree)(implicit ctx: Context): Option[Lambda]
+
+### matchLambdaTypeTree
+def matchLambdaTypeTree(tree: Tree)(implicit ctx: Context): Option[LambdaTypeTree]
+
+### matchLiteral
+def matchLiteral(tree: Tree)(implicit ctx: Context): Option[Literal]
+
+### matchMatch
+def matchMatch(tree: Tree)(implicit ctx: Context): Option[Match]
+
+### matchMatchType
+def matchMatchType(tpe: TypeOrBounds)(implicit ctx: Context): Option[MatchType]
+
+### matchMatchTypeTree
+def matchMatchTypeTree(tree: Tree)(implicit ctx: Context): Option[MatchTypeTree]
+
+### matchMethodType
+def matchMethodType(tpe: TypeOrBounds)(implicit ctx: Context): Option[MethodType]
+
+### matchNamedArg
+def matchNamedArg(tree: Tree)(implicit ctx: Context): Option[NamedArg]
+
+### matchNew
+def matchNew(tree: Tree)(implicit ctx: Context): Option[New]
+
+### matchNoPrefix
+def matchNoPrefix(x: TypeOrBounds)(implicit ctx: Context): Option[NoPrefix]
+
+### matchNoSymbol
+def matchNoSymbol(symbol: Symbol)(implicit ctx: Context): Boolean
+
+### matchOmitSelector
+def matchOmitSelector(self: ImportSelector)(implicit ctx: Context): Option[OmitSelector]
+
+### matchOrType
+def matchOrType(tpe: TypeOrBounds)(implicit ctx: Context): Option[OrType]
+
+### matchPackageClause
+def matchPackageClause(tree: Tree)(implicit ctx: Context): Option[PackageClause]
+
+### matchPackageDef
+def matchPackageDef(tree: Tree)(implicit ctx: Context): Option[PackageDef]
+
+### matchPackageDefSymbol
+def matchPackageDefSymbol(symbol: Symbol)(implicit ctx: Context): Option[PackageDefSymbol]
+
+### matchParamRef
+def matchParamRef(tpe: TypeOrBounds)(implicit ctx: Context): Option[ParamRef]
+
+### matchPattern_Alternatives
+def matchPattern_Alternatives(pattern: Pattern)(implicit ctx: Context): Option[Alternatives]
+
+### matchPattern_Bind
+def matchPattern_Bind(x: Pattern)(implicit ctx: Context): Option[Bind]
+
+### matchPattern_TypeTest
+def matchPattern_TypeTest(pattern: Pattern)(implicit ctx: Context): Option[TypeTest]
+
+### matchPattern_Unapply
+def matchPattern_Unapply(pattern: Pattern)(implicit ctx: Context): Option[Unapply]
+
+### matchPattern_Value
+def matchPattern_Value(pattern: Pattern): Option[Value]
+
+### matchPattern_WildcardPattern
+def matchPattern_WildcardPattern(pattern: Pattern)(implicit ctx: Context): Option[WildcardPattern]
+
+### matchPolyType
+def matchPolyType(tpe: TypeOrBounds)(implicit ctx: Context): Option[PolyType]
+
+### matchProjection
+def matchProjection(tree: Tree)(implicit ctx: Context): Option[Projection]
+
+### matchRecursiveThis
+def matchRecursiveThis(tpe: TypeOrBounds)(implicit ctx: Context): Option[RecursiveThis]
+
+### matchRecursiveType
+def matchRecursiveType(tpe: TypeOrBounds)(implicit ctx: Context): Option[RecursiveType]
+
+### matchRef
+def matchRef(tree: Tree)(implicit ctx: Context): Option[Ref]
+
+### matchRefined
+def matchRefined(tree: Tree)(implicit ctx: Context): Option[Refined]
+
+### matchRefinement
+def matchRefinement(tpe: TypeOrBounds)(implicit ctx: Context): Option[Refinement]
+
+### matchRenameSelector
+def matchRenameSelector(self: ImportSelector)(implicit ctx: Context): Option[RenameSelector]
+
+### matchRepeated
+def matchRepeated(tree: Tree)(implicit ctx: Context): Option[Repeated]
+
+### matchReturn
+def matchReturn(tree: Tree)(implicit ctx: Context): Option[Return]
+
+### matchSelect
+def matchSelect(tree: Tree)(implicit ctx: Context): Option[Select]
+
+### matchSelectOuter
+def matchSelectOuter(tree: Tree)(implicit ctx: Context): Option[SelectOuter]
+
+### matchSimpleSelector
+def matchSimpleSelector(self: ImportSelector)(implicit ctx: Context): Option[SimpleSelector]
+
+### matchSingleton
+def matchSingleton(tree: Tree)(implicit ctx: Context): Option[Singleton]
+
+### matchStatement
+def matchStatement(tree: Tree)(implicit ctx: Context): Option[Statement]
+
+### matchSuper
+def matchSuper(tree: Tree)(implicit ctx: Context): Option[Super]
+
+### matchSuperType
+def matchSuperType(tpe: TypeOrBounds)(implicit ctx: Context): Option[SuperType]
+
+### matchSymRef
+def matchSymRef(tpe: TypeOrBounds)(implicit ctx: Context): Option[SymRef]
+
+### matchSymRef_unapply
+def matchSymRef_unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[(Symbol, TypeOrBounds)]
+
+### matchTerm
+def matchTerm(tree: Tree)(implicit ctx: Context): Option[Term]
+
+### matchTermRef
+def matchTermRef(tpe: TypeOrBounds)(implicit ctx: Context): Option[TermRef]
+
+### matchTermSymbol
+def matchTermSymbol(symbol: Symbol)(implicit ctx: Context): Option[TermSymbol]
+
+### matchThis
+def matchThis(tree: Tree)(implicit ctx: Context): Option[This]
+
+### matchThisType
+def matchThisType(tpe: TypeOrBounds)(implicit ctx: Context): Option[ThisType]
+
+### matchTry
+def matchTry(tree: Tree)(implicit ctx: Context): Option[Try]
+
+### matchType
+def matchType(x: TypeOrBounds)(implicit ctx: Context): Option[Type]
+
+### matchTypeApply
+def matchTypeApply(tree: Tree)(implicit ctx: Context): Option[TypeApply]
+
+### matchTypeBind
+def matchTypeBind(tree: Tree)(implicit ctx: Context): Option[TypeBind]
+
+### matchTypeBindSymbol
+def matchTypeBindSymbol(symbol: Symbol)(implicit ctx: Context): Option[TypeBindSymbol]
+
+### matchTypeBlock
+def matchTypeBlock(tree: Tree)(implicit ctx: Context): Option[TypeBlock]
+
+### matchTypeBounds
+def matchTypeBounds(x: TypeOrBounds)(implicit ctx: Context): Option[TypeBounds]
+
+### matchTypeBoundsTree
+def matchTypeBoundsTree(tree: Tree)(implicit ctx: Context): Option[TypeBoundsTree]
+
+### matchTypeCaseDef
+def matchTypeCaseDef(tree: Tree)(implicit ctx: Context): Option[TypeCaseDef]
+
+### matchTypeDef
+def matchTypeDef(tree: Tree)(implicit ctx: Context): Option[TypeDef]
+
+### matchTypeDefSymbol
+def matchTypeDefSymbol(symbol: Symbol)(implicit ctx: Context): Option[TypeDefSymbol]
+
+### matchTypeIdent
+def matchTypeIdent(tree: Tree)(implicit ctx: Context): Option[TypeIdent]
+
+### matchTypeLambda
+def matchTypeLambda(tpe: TypeOrBounds)(implicit ctx: Context): Option[TypeLambda]
+
+### matchTypeRef
+def matchTypeRef(tpe: TypeOrBounds)(implicit ctx: Context): Option[TypeRef]
+
+### matchTypeSelect
+def matchTypeSelect(tree: Tree)(implicit ctx: Context): Option[TypeSelect]
+
+### matchTypeSymbol
+def matchTypeSymbol(symbol: Symbol)(implicit ctx: Context): Option[TypeSymbol]
+
+### matchTypeTree
+def matchTypeTree(tree: Tree)(implicit ctx: Context): Option[TypeTree]
+
+### matchTyped
+def matchTyped(tree: Tree)(implicit ctx: Context): Option[Typed]
+
+### matchValDef
+def matchValDef(tree: Tree)(implicit ctx: Context): Option[ValDef]
+
+### matchValDefSymbol
+def matchValDefSymbol(symbol: Symbol)(implicit ctx: Context): Option[ValDefSymbol]
+
+### matchWhile
+def matchWhile(tree: Tree)(implicit ctx: Context): Option[While]
+
+### matchWildcardTypeTree
+def matchWildcardTypeTree(tree: Tree)(implicit ctx: Context): Option[WildcardTypeTree]
+
+### rootContext
+def rootContext: Context
+Context of the macro expansion
+
+### rootPosition
+def rootPosition: Position
+Root position of this tasty context. For macros it corresponds to the expansion site.
+
+### settings
+def settings: Settings
+
+### typeChecks
+def typeChecks(code: String)(implicit ctx: Context): Boolean
+Whether the code type checks in the given context?
+
+***code*** The code to be type checked
+The code should be a sequence of expressions or statements that may appear in a block.
+
+### warning
+def warning(msg: => String, source: SourceFile, start: Int, end: Int)(implicit ctx: Context): Unit
+Report a compilation warning with the given message at the given position range
+
+### warning
+def warning(msg: => String, pos: Position)(implicit ctx: Context): Unit
+Report a compilation warning with the given message at the given position
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps.md
new file mode 100644
index 000000000000..dc3f929b56e1
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps.md
@@ -0,0 +1,19 @@
+scala.tasty.reflect
+# trait PatternOps
+
+trait PatternOps extends Core
+## Concrete Type Members:
+### Pattern
+final object Pattern
+### AlternativesAPI
+class AlternativesAPI
+### BindAPI
+class BindAPI
+### PatternAPI
+class PatternAPI
+### TypeTestAPI
+class TypeTestAPI
+### UnapplyAPI
+class UnapplyAPI
+### ValueAPI
+class ValueAPI
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/AlternativesAPI.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/AlternativesAPI.md
new file mode 100644
index 000000000000..4b6a9f078aa5
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/AlternativesAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.PatternOps
+# class AlternativesAPI
+
+class AlternativesAPI
+## Constructors:
+AlternativesAPI(alternatives: Alternatives)
+
+## Concrete Value Members:
+### patterns
+def patterns(implicit ctx: Context): List[Pattern]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/BindAPI.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/BindAPI.md
new file mode 100644
index 000000000000..11afd2a2c8a3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/BindAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.PatternOps
+# class BindAPI
+
+class BindAPI
+## Constructors:
+BindAPI(bind: Bind)
+
+## Concrete Value Members:
+### name
+def name(implicit ctx: Context): String
+
+### pattern
+def pattern(implicit ctx: Context): Pattern
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$.md
new file mode 100644
index 000000000000..8c5de20c2f95
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$.md
@@ -0,0 +1,29 @@
+scala.tasty.reflect.PatternOps
+# object Pattern
+
+final object Pattern extends Serializable
+## Concrete Type Members:
+### Alternatives
+final object Alternatives
+### Bind
+final object Bind
+### IsAlternatives
+final object IsAlternatives
+### IsBind
+final object IsBind
+### IsTypeTest
+final object IsTypeTest
+### IsUnapply
+final object IsUnapply
+### IsValue
+final object IsValue
+### IsWildcardPattern
+final object IsWildcardPattern
+### TypeTest
+final object TypeTest
+### Unapply
+final object Unapply
+### Value
+final object Value
+### WildcardPattern
+final object WildcardPattern
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Alternatives$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Alternatives$.md
new file mode 100644
index 000000000000..e7879fb1331c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Alternatives$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object Alternatives
+
+final object Alternatives extends Serializable
+## Concrete Value Members:
+### apply
+def apply(patterns: List[Pattern])(implicit ctx: Context): Alternatives
+
+### copy
+def copy(original: Alternatives)(patterns: List[Pattern])(implicit ctx: Context): Alternatives
+
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Option[List[Pattern]]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Bind$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Bind$.md
new file mode 100644
index 000000000000..b3d491b14dbb
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Bind$.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object Bind
+
+final object Bind extends Serializable
+## Concrete Value Members:
+### copy
+def copy(original: Bind)(name: String, pattern: Pattern)(implicit ctx: Context): Bind
+
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Option[(String, Pattern)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsAlternatives$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsAlternatives$.md
new file mode 100644
index 000000000000..ea26ae8d4ea1
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsAlternatives$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object IsAlternatives
+
+final object IsAlternatives extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Option[Alternatives]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsBind$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsBind$.md
new file mode 100644
index 000000000000..e8cc0905adf8
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsBind$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object IsBind
+
+final object IsBind extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Option[Bind]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsTypeTest$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsTypeTest$.md
new file mode 100644
index 000000000000..39ef1672c2fe
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsTypeTest$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object IsTypeTest
+
+final object IsTypeTest extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Option[TypeTest]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsUnapply$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsUnapply$.md
new file mode 100644
index 000000000000..de5cfd0c834b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsUnapply$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object IsUnapply
+
+final object IsUnapply extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Option[Unapply]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsValue$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsValue$.md
new file mode 100644
index 000000000000..b450a25b269e
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsValue$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object IsValue
+
+final object IsValue extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Option[Value]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsWildcardPattern$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsWildcardPattern$.md
new file mode 100644
index 000000000000..81f6c6093d0c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/IsWildcardPattern$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object IsWildcardPattern
+
+final object IsWildcardPattern extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Option[WildcardPattern]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/TypeTest$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/TypeTest$.md
new file mode 100644
index 000000000000..8cc5613ef1dc
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/TypeTest$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object TypeTest
+
+final object TypeTest extends Serializable
+## Concrete Value Members:
+### apply
+def apply(tpt: TypeTree)(implicit ctx: Context): TypeTest
+
+### copy
+def copy(original: TypeTest)(tpt: TypeTree)(implicit ctx: Context): TypeTest
+
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Option[TypeTree]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Unapply$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Unapply$.md
new file mode 100644
index 000000000000..f0ae73cf4117
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Unapply$.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object Unapply
+
+final object Unapply extends Serializable
+## Concrete Value Members:
+### copy
+def copy(original: Unapply)(fun: Term, implicits: List[Term], patterns: List[Pattern])(implicit ctx: Context): Unapply
+
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Option[(Term, List[Term], List[Pattern])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Value$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Value$.md
new file mode 100644
index 000000000000..995132255792
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/Value$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object Value
+
+final object Value extends Serializable
+## Concrete Value Members:
+### apply
+def apply(tpt: Term)(implicit ctx: Context): Value
+
+### copy
+def copy(original: Value)(tpt: Term)(implicit ctx: Context): Value
+
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Option[Term]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/WildcardPattern$.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/WildcardPattern$.md
new file mode 100644
index 000000000000..62365a23a847
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/Pattern$/WildcardPattern$.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.PatternOps.Pattern$
+# object WildcardPattern
+
+final object WildcardPattern extends Serializable
+## Concrete Value Members:
+### apply
+def apply(tpe: TypeOrBounds)(implicit ctx: Context): WildcardPattern
+
+### unapply
+def unapply(pattern: Pattern)(implicit ctx: Context): Boolean
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/PatternAPI.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/PatternAPI.md
new file mode 100644
index 000000000000..c521b52e74f6
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/PatternAPI.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.PatternOps
+# class PatternAPI
+
+class PatternAPI
+## Constructors:
+PatternAPI(self: Pattern)
+
+## Concrete Value Members:
+### pos
+def pos(implicit ctx: Context): Position
+Position in the source code
+
+### symbol
+def symbol(implicit ctx: Context): Symbol
+
+### tpe
+def tpe(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/TypeTestAPI.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/TypeTestAPI.md
new file mode 100644
index 000000000000..33f46d725304
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/TypeTestAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.PatternOps
+# class TypeTestAPI
+
+class TypeTestAPI
+## Constructors:
+TypeTestAPI(typeTest: TypeTest)
+
+## Concrete Value Members:
+### tpt
+def tpt(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/UnapplyAPI.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/UnapplyAPI.md
new file mode 100644
index 000000000000..28e8734f7d77
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/UnapplyAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.PatternOps
+# class UnapplyAPI
+
+class UnapplyAPI
+## Constructors:
+UnapplyAPI(unapply: Unapply)
+
+## Concrete Value Members:
+### fun
+def fun(implicit ctx: Context): Term
+
+### implicits
+def implicits(implicit ctx: Context): List[Term]
+
+### patterns
+def patterns(implicit ctx: Context): List[Pattern]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PatternOps/ValueAPI.md b/tastydoc/documentation/scala/tasty/reflect/PatternOps/ValueAPI.md
new file mode 100644
index 000000000000..c151bcd9e8ff
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PatternOps/ValueAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.PatternOps
+# class ValueAPI
+
+class ValueAPI
+## Constructors:
+ValueAPI(value: Value)
+
+## Concrete Value Members:
+### value
+def value(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PositionOps.md b/tastydoc/documentation/scala/tasty/reflect/PositionOps.md
new file mode 100644
index 000000000000..780959739a26
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PositionOps.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect
+# trait PositionOps
+
+trait PositionOps extends Core
+## Concrete Type Members:
+### PositionAPI
+class PositionAPI
+### SourceFileAPI
+class SourceFileAPI
diff --git a/tastydoc/documentation/scala/tasty/reflect/PositionOps/PositionAPI.md b/tastydoc/documentation/scala/tasty/reflect/PositionOps/PositionAPI.md
new file mode 100644
index 000000000000..43422ca597a4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PositionOps/PositionAPI.md
@@ -0,0 +1,44 @@
+scala.tasty.reflect.PositionOps
+# class PositionAPI
+
+class PositionAPI
+## Constructors:
+PositionAPI(pos: Position)
+
+## Concrete Value Members:
+### end
+def end: Int
+The end offset in the source file
+
+### endColumn
+def endColumn: Int
+The end column in the source file
+
+### endLine
+def endLine: Int
+The end line in the source file
+
+### exists
+def exists: Boolean
+Does this position exist
+
+### sourceCode
+def sourceCode: String
+Source code within the position
+
+### sourceFile
+def sourceFile: SourceFile
+Source file in which this position is located
+
+### start
+def start: Int
+The start offset in the source file
+
+### startColumn
+def startColumn: Int
+The start column in the source file
+
+### startLine
+def startLine: Int
+The start line in the source file
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/PositionOps/SourceFileAPI.md b/tastydoc/documentation/scala/tasty/reflect/PositionOps/SourceFileAPI.md
new file mode 100644
index 000000000000..c9684868c2b6
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/PositionOps/SourceFileAPI.md
@@ -0,0 +1,16 @@
+scala.tasty.reflect.PositionOps
+# class SourceFileAPI
+
+class SourceFileAPI
+## Constructors:
+SourceFileAPI(sourceFile: SourceFile)
+
+## Concrete Value Members:
+### content
+def content: String
+Content of this source file
+
+### jpath
+def jpath: Path
+Path to this source file
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Printers.md b/tastydoc/documentation/scala/tasty/reflect/Printers.md
new file mode 100644
index 000000000000..eb6be6647c78
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Printers.md
@@ -0,0 +1,40 @@
+scala.tasty.reflect
+# trait Printers
+
+trait Printers extends Core with ConstantOps with FlagsOps with IdOps with ImportSelectorOps with PatternOps with PositionOps with SignatureOps with StandardDefinitions with SymbolOps with TreeOps with TypeOrBoundsOps
+## Abstract Type Members:
+### Printer
+abstract class Printer
+## Concrete Type Members:
+### ConstantShowDeco
+class ConstantShowDeco
+Adds `show` as an extension method of a `Constant`
+
+### ExtractorsPrinter
+class ExtractorsPrinter
+### FlagsShowDeco
+class FlagsShowDeco
+Adds `show` as an extension method of a `Flags`
+
+### PatternShowDeco
+class PatternShowDeco
+Adds `show` as an extension method of a `Pattern`
+
+### SourceCodePrinter
+class SourceCodePrinter
+### SymbolShowDeco
+class SymbolShowDeco
+Adds `show` as an extension method of a `Symbol`
+
+### TreeShowDeco
+class TreeShowDeco
+Adds `show` as an extension method of a `Tree`
+
+### TypeOrBoundsShowDeco
+class TypeOrBoundsShowDeco
+Adds `show` as an extension method of a `TypeOrBounds`
+
+## Concrete Value Members:
+### typeOf
+def typeOf[T](implicit evidence$2: Type[T]): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Printers/ConstantShowDeco.md b/tastydoc/documentation/scala/tasty/reflect/Printers/ConstantShowDeco.md
new file mode 100644
index 000000000000..df0d2d0cdee3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Printers/ConstantShowDeco.md
@@ -0,0 +1,19 @@
+scala.tasty.reflect.Printers
+# class ConstantShowDeco
+
+class ConstantShowDeco
+Adds `show` as an extension method of a `Constant`
+
+## Constructors:
+ConstantShowDeco(const: Constant)
+
+## Concrete Value Members:
+### show
+def show(implicit ctx: Context): String
+Shows the tree as fully typed source code.
+Will print Ansi colors if ctx.printColors is enabled.
+
+### showExtractors
+def showExtractors(implicit ctx: Context): String
+Shows the tree as extractors
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Printers/ExtractorsPrinter.md b/tastydoc/documentation/scala/tasty/reflect/Printers/ExtractorsPrinter.md
new file mode 100644
index 000000000000..a298c0634839
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Printers/ExtractorsPrinter.md
@@ -0,0 +1,23 @@
+scala.tasty.reflect.Printers
+# class ExtractorsPrinter
+
+class ExtractorsPrinter extends Printer
+## Concrete Value Members:
+### showConstant
+def showConstant(const: Constant)(implicit ctx: Context): String
+
+### showFlags
+def showFlags(flags: Flags)(implicit ctx: Context): String
+
+### showPattern
+def showPattern(pattern: Pattern)(implicit ctx: Context): String
+
+### showSymbol
+def showSymbol(symbol: Symbol)(implicit ctx: Context): String
+
+### showTree
+def showTree(tree: Tree)(implicit ctx: Context): String
+
+### showTypeOrBounds
+def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Printers/FlagsShowDeco.md b/tastydoc/documentation/scala/tasty/reflect/Printers/FlagsShowDeco.md
new file mode 100644
index 000000000000..03ec559a9c5e
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Printers/FlagsShowDeco.md
@@ -0,0 +1,19 @@
+scala.tasty.reflect.Printers
+# class FlagsShowDeco
+
+class FlagsShowDeco
+Adds `show` as an extension method of a `Flags`
+
+## Constructors:
+FlagsShowDeco(flags: Flags)
+
+## Concrete Value Members:
+### show
+def show(implicit ctx: Context): String
+Shows the tree as fully typed source code.
+Will print Ansi colors if ctx.printColors is enabled.
+
+### showExtractors
+def showExtractors(implicit ctx: Context): String
+Shows the tree as extractors
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Printers/PatternShowDeco.md b/tastydoc/documentation/scala/tasty/reflect/Printers/PatternShowDeco.md
new file mode 100644
index 000000000000..dff2059298be
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Printers/PatternShowDeco.md
@@ -0,0 +1,19 @@
+scala.tasty.reflect.Printers
+# class PatternShowDeco
+
+class PatternShowDeco
+Adds `show` as an extension method of a `Pattern`
+
+## Constructors:
+PatternShowDeco(pattern: Pattern)
+
+## Concrete Value Members:
+### show
+def show(implicit ctx: Context): String
+Shows the tree as fully typed source code.
+Will print Ansi colors if ctx.printColors is enabled.
+
+### showExtractors
+def showExtractors(implicit ctx: Context): String
+Shows the tree as extractors
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Printers/Printer.md b/tastydoc/documentation/scala/tasty/reflect/Printers/Printer.md
new file mode 100644
index 000000000000..1597e0462d09
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Printers/Printer.md
@@ -0,0 +1,23 @@
+scala.tasty.reflect.Printers
+# class Printer
+
+abstract class Printer
+## Concrete Value Members:
+### showConstant
+def showConstant(const: Constant)(implicit ctx: Context): String
+
+### showFlags
+def showFlags(flags: Flags)(implicit ctx: Context): String
+
+### showPattern
+def showPattern(pattern: Pattern)(implicit ctx: Context): String
+
+### showSymbol
+def showSymbol(symbol: Symbol)(implicit ctx: Context): String
+
+### showTree
+def showTree(tree: Tree)(implicit ctx: Context): String
+
+### showTypeOrBounds
+def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Printers/SourceCodePrinter.md b/tastydoc/documentation/scala/tasty/reflect/Printers/SourceCodePrinter.md
new file mode 100644
index 000000000000..6f19d9c0b11c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Printers/SourceCodePrinter.md
@@ -0,0 +1,26 @@
+scala.tasty.reflect.Printers
+# class SourceCodePrinter
+
+class SourceCodePrinter extends Printer
+## Concrete Type Members:
+### PackageObject
+final object PackageObject
+## Concrete Value Members:
+### showConstant
+def showConstant(const: Constant)(implicit ctx: Context): String
+
+### showFlags
+def showFlags(flags: Flags)(implicit ctx: Context): String
+
+### showPattern
+def showPattern(pattern: Pattern)(implicit ctx: Context): String
+
+### showSymbol
+def showSymbol(symbol: Symbol)(implicit ctx: Context): String
+
+### showTree
+def showTree(tree: Tree)(implicit ctx: Context): String
+
+### showTypeOrBounds
+def showTypeOrBounds(tpe: TypeOrBounds)(implicit ctx: Context): String
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Printers/SourceCodePrinter/PackageObject$.md b/tastydoc/documentation/scala/tasty/reflect/Printers/SourceCodePrinter/PackageObject$.md
new file mode 100644
index 000000000000..5fc2b8fc23f2
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Printers/SourceCodePrinter/PackageObject$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.Printers.SourceCodePrinter
+# object PackageObject
+
+final object PackageObject extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Tree]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Printers/SymbolShowDeco.md b/tastydoc/documentation/scala/tasty/reflect/Printers/SymbolShowDeco.md
new file mode 100644
index 000000000000..13fa1fe98052
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Printers/SymbolShowDeco.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.Printers
+# class SymbolShowDeco
+
+class SymbolShowDeco
+Adds `show` as an extension method of a `Symbol`
+
+## Constructors:
+SymbolShowDeco(symbol: Symbol)
+
+## Concrete Value Members:
+### show
+def show(implicit ctx: Context): String
+Shows the tree as fully typed source code
+
+### showExtractors
+def showExtractors(implicit ctx: Context): String
+Shows the tree as extractors
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Printers/TreeShowDeco.md b/tastydoc/documentation/scala/tasty/reflect/Printers/TreeShowDeco.md
new file mode 100644
index 000000000000..73c6281330df
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Printers/TreeShowDeco.md
@@ -0,0 +1,19 @@
+scala.tasty.reflect.Printers
+# class TreeShowDeco
+
+class TreeShowDeco
+Adds `show` as an extension method of a `Tree`
+
+## Constructors:
+TreeShowDeco(tree: Tree)
+
+## Concrete Value Members:
+### show
+def show(implicit ctx: Context): String
+Shows the tree as fully typed source code.
+Will print Ansi colors if ctx.printColors is enabled.
+
+### showExtractors
+def showExtractors(implicit ctx: Context): String
+Shows the tree as extractors
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/Printers/TypeOrBoundsShowDeco.md b/tastydoc/documentation/scala/tasty/reflect/Printers/TypeOrBoundsShowDeco.md
new file mode 100644
index 000000000000..7df47ba3af70
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/Printers/TypeOrBoundsShowDeco.md
@@ -0,0 +1,19 @@
+scala.tasty.reflect.Printers
+# class TypeOrBoundsShowDeco
+
+class TypeOrBoundsShowDeco
+Adds `show` as an extension method of a `TypeOrBounds`
+
+## Constructors:
+TypeOrBoundsShowDeco(tpe: TypeOrBounds)
+
+## Concrete Value Members:
+### show
+def show(implicit ctx: Context): String
+Shows the tree as fully typed source code.
+Will print Ansi colors if ctx.printColors is enabled.
+
+### showExtractors
+def showExtractors(implicit ctx: Context): String
+Shows the tree as extractors
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/QuotedOps.md b/tastydoc/documentation/scala/tasty/reflect/QuotedOps.md
new file mode 100644
index 000000000000..b8b6c0974b12
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/QuotedOps.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect
+# trait QuotedOps
+
+trait QuotedOps extends Core
+Extension methods on scala.quoted.{Expr|Type} to convert to scala.tasty.Tasty objects
+
+## Concrete Type Members:
+### QuotedExprAPI
+class QuotedExprAPI
+### QuotedTypeAPI
+class QuotedTypeAPI
+### TermToQuotedAPI
+class TermToQuotedAPI
+### TypeToQuotedAPI
+class TypeToQuotedAPI
diff --git a/tastydoc/documentation/scala/tasty/reflect/QuotedOps/QuotedExprAPI.md b/tastydoc/documentation/scala/tasty/reflect/QuotedOps/QuotedExprAPI.md
new file mode 100644
index 000000000000..a04e5f63d9d6
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/QuotedOps/QuotedExprAPI.md
@@ -0,0 +1,20 @@
+scala.tasty.reflect.QuotedOps
+# class QuotedExprAPI
+
+class QuotedExprAPI[T]
+## Constructors:
+QuotedExprAPI(expr: Expr[T])
+
+## Concrete Value Members:
+### cast
+def cast[U](implicit evidence$17: Type[U], ctx: Context): Expr[U]
+Checked cast to a `quoted.Expr[U]`
+
+### show
+def show(implicit ctx: Context): String
+Show a source code like representation of this expression
+
+### unseal
+def unseal(implicit ctx: Context): Term
+View this expression `quoted.Expr[T]` as a `Term`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/QuotedOps/QuotedTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/QuotedOps/QuotedTypeAPI.md
new file mode 100644
index 000000000000..802b344b2169
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/QuotedOps/QuotedTypeAPI.md
@@ -0,0 +1,16 @@
+scala.tasty.reflect.QuotedOps
+# class QuotedTypeAPI
+
+class QuotedTypeAPI[T <: scala.AnyKind]
+## Constructors:
+QuotedTypeAPI(tpe: Type[T])
+
+## Concrete Value Members:
+### show
+def show(implicit ctx: Context): String
+Show a source code like representation of this type
+
+### unseal
+def unseal(implicit ctx: Context): TypeTree
+View this expression `quoted.Type[T]` as a `TypeTree`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/QuotedOps/TermToQuotedAPI.md b/tastydoc/documentation/scala/tasty/reflect/QuotedOps/TermToQuotedAPI.md
new file mode 100644
index 000000000000..c5c8b6587b98
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/QuotedOps/TermToQuotedAPI.md
@@ -0,0 +1,12 @@
+scala.tasty.reflect.QuotedOps
+# class TermToQuotedAPI
+
+class TermToQuotedAPI
+## Constructors:
+TermToQuotedAPI(term: Term)
+
+## Concrete Value Members:
+### seal
+def seal(implicit ctx: Context): Expr[Any]
+Convert `Term` to an `quoted.Expr[Any]`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/QuotedOps/TypeToQuotedAPI.md b/tastydoc/documentation/scala/tasty/reflect/QuotedOps/TypeToQuotedAPI.md
new file mode 100644
index 000000000000..55967aaea09c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/QuotedOps/TypeToQuotedAPI.md
@@ -0,0 +1,12 @@
+scala.tasty.reflect.QuotedOps
+# class TypeToQuotedAPI
+
+class TypeToQuotedAPI
+## Constructors:
+TypeToQuotedAPI(tpe: Type)
+
+## Concrete Value Members:
+### seal
+def seal(implicit ctx: Context): Type[Nothing <: AnyKind]
+Convert `Type` to an `quoted.Type[_]`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/ReportingOps.md b/tastydoc/documentation/scala/tasty/reflect/ReportingOps.md
new file mode 100644
index 000000000000..f0d76a86b643
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/ReportingOps.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect
+# trait ReportingOps
+
+trait ReportingOps extends Core
+## Concrete Value Members:
+### error
+def error(msg: => String, source: SourceFile, start: Int, end: Int)(implicit ctx: Context): Unit
+
+### error
+def error(msg: => String, pos: Position)(implicit ctx: Context): Unit
+
+### warning
+def warning(msg: => String, source: SourceFile, start: Int, end: Int)(implicit ctx: Context): Unit
+
+### warning
+def warning(msg: => String, pos: Position)(implicit ctx: Context): Unit
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/RootPosition.md b/tastydoc/documentation/scala/tasty/reflect/RootPosition.md
new file mode 100644
index 000000000000..129bbf039983
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/RootPosition.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect
+# trait RootPosition
+
+trait RootPosition extends Core
+## Concrete Value Members:
+### rootPosition
+def rootPosition: Position
+Root position of this tasty context. For macros it corresponds to the expansion site.
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SignatureOps.md b/tastydoc/documentation/scala/tasty/reflect/SignatureOps.md
new file mode 100644
index 000000000000..f9abb2d4f84f
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SignatureOps.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect
+# trait SignatureOps
+
+trait SignatureOps extends Core
+## Concrete Type Members:
+### Signature
+final object Signature
+Erased (JVM) signatures.
+
+### SignatureAPI
+class SignatureAPI
diff --git a/tastydoc/documentation/scala/tasty/reflect/SignatureOps/Signature$.md b/tastydoc/documentation/scala/tasty/reflect/SignatureOps/Signature$.md
new file mode 100644
index 000000000000..95930d6b35c0
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SignatureOps/Signature$.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.SignatureOps
+# object Signature
+
+final object Signature extends Serializable
+Erased (JVM) signatures.
+
+## Concrete Value Members:
+### unapply
+def unapply(sig: Signature)(implicit ctx: Context): Option[(List[String], String)]
+Matches the erased (JVM) signature and returns its parameters and result type.
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SignatureOps/SignatureAPI.md b/tastydoc/documentation/scala/tasty/reflect/SignatureOps/SignatureAPI.md
new file mode 100644
index 000000000000..2367f3d1015f
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SignatureOps/SignatureAPI.md
@@ -0,0 +1,16 @@
+scala.tasty.reflect.SignatureOps
+# class SignatureAPI
+
+class SignatureAPI
+## Constructors:
+SignatureAPI(sig: Signature)
+
+## Concrete Value Members:
+### paramSigs
+def paramSigs: List[String]
+The (JVM) erased signatures of the parameters
+
+### resultSig
+def resultSig: String
+The (JVM) erased result type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions.md b/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions.md
new file mode 100644
index 000000000000..2fc964f56572
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions.md
@@ -0,0 +1,23 @@
+scala.tasty.reflect
+# trait StandardDefinitions
+
+trait StandardDefinitions extends Core
+## Concrete Type Members:
+### definitions
+final object definitions
+A value containing all standard definitions in DefinitionsAPI
+
+***Group*** Definitions
+
+### StandardSymbols
+trait StandardSymbols
+Defines standard symbols (and types via its base trait).
+
+***Group*** API
+
+### StandardTypes
+trait StandardTypes
+Defines standard types.
+
+***Group*** Definitions
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions/StandardSymbols.md b/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions/StandardSymbols.md
new file mode 100644
index 000000000000..8c4e604b10aa
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions/StandardSymbols.md
@@ -0,0 +1,193 @@
+scala.tasty.reflect.StandardDefinitions
+# trait StandardSymbols
+
+trait StandardSymbols
+Defines standard symbols (and types via its base trait).
+
+***Group*** API
+
+## Concrete Value Members:
+### AnyClass
+def AnyClass: Symbol
+The class symbol of core class `scala.Any`.
+
+### AnyRefClass
+def AnyRefClass: Symbol
+The type symbol of core class `scala.AnyRef`.
+
+### AnyValClass
+def AnyValClass: Symbol
+The class symbol of core class `scala.AnyVal`.
+
+### ArrayClass
+def ArrayClass: Symbol
+The class symbol of class `scala.Array`.
+
+### ArrayModule
+def ArrayModule: Symbol
+The module symbol of module `scala.Array`.
+
+### Array_apply
+def Array_apply: Symbol
+The method symbol of method `apply` in class `scala.Array`.
+
+### Array_clone
+def Array_clone: Symbol
+The method symbol of method `clone` in class `scala.Array`.
+
+### Array_length
+def Array_length: Symbol
+The method symbol of method `length` in class `scala.Array`.
+
+### Array_update
+def Array_update: Symbol
+The method symbol of method `update` in class `scala.Array`.
+
+### BooleanClass
+def BooleanClass: Symbol
+The class symbol of primitive class `scala.Boolean`.
+
+### ByteClass
+def ByteClass: Symbol
+The class symbol of primitive class `scala.Byte`.
+
+### CharClass
+def CharClass: Symbol
+The class symbol of primitive class `scala.Char`.
+
+### ClassClass
+def ClassClass: Symbol
+The class symbol of class `java.lang.Class`.
+
+### DoubleClass
+def DoubleClass: Symbol
+The class symbol of primitive class `scala.Double`.
+
+### EmptyPackageClass
+def EmptyPackageClass: Symbol
+The class symbol of empty package `_root_._empty_`.
+
+### FloatClass
+def FloatClass: Symbol
+The class symbol of primitive class `scala.Float`.
+
+### FunctionClass
+def FunctionClass(arity: Int, isImplicit: Boolean, isErased: Boolean): Symbol
+Function-like object that maps arity to symbols for classes `scala.FunctionX`.
+* 0th element is `Function0`
+* 1st element is `Function1`
+* ...
+* Nth element is `FunctionN`
+
+### IntClass
+def IntClass: Symbol
+The class symbol of primitive class `scala.Int`.
+
+### JavaLangPackage
+def JavaLangPackage: Symbol
+The module symbol of package `java.lang`.
+
+### LongClass
+def LongClass: Symbol
+The class symbol of primitive class `scala.Long`.
+
+### NoneModule
+def NoneModule: Symbol
+The module symbol of module `scala.None`.
+
+### NothingClass
+def NothingClass: Symbol
+The class symbol of core class `scala.Nothing`.
+
+### NullClass
+def NullClass: Symbol
+The class symbol of core class `scala.Null`.
+
+### ObjectClass
+def ObjectClass: Symbol
+The class symbol of core class `java.lang.Object`.
+
+### OptionClass
+def OptionClass: Symbol
+The class symbol of class `scala.Option`.
+
+### PredefModule
+def PredefModule: Symbol
+The module symbol of module `scala.Predef`.
+
+### ProductClass
+def ProductClass: Symbol
+Function-like object that maps arity to symbols for classes `scala.Product`
+
+### RepeatedParamClass
+def RepeatedParamClass: ClassDefSymbol
+A dummy class symbol that is used to indicate repeated parameters
+compiled by the Scala compiler.
+
+### RootClass
+def RootClass: Symbol
+The class symbol of root package `_root_`.
+
+### RootPackage
+def RootPackage: Symbol
+The module symbol of root package `_root_`.
+
+### ScalaNumericValueClasses
+def ScalaNumericValueClasses: List[Symbol]
+Contains Scala numeric value classes:
+* Byte
+* Short
+* Int
+* Long
+* Float
+* Double
+* Char
+
+### ScalaPackage
+def ScalaPackage: Symbol
+The module symbol of package `scala`.
+
+### ScalaPackageClass
+def ScalaPackageClass: Symbol
+The class symbol of package `scala`.
+
+### ScalaPrimitiveValueClasses
+def ScalaPrimitiveValueClasses: List[Symbol]
+Contains Scala primitive value classes:
+* Byte
+* Short
+* Int
+* Long
+* Float
+* Double
+* Char
+* Boolean
+* Unit
+
+### ShortClass
+def ShortClass: Symbol
+The class symbol of primitive class `scala.Short`.
+
+### SomeModule
+def SomeModule: Symbol
+The module symbol of module `scala.Some`.
+
+### StringClass
+def StringClass: Symbol
+The class symbol of class `scala.String`.
+
+### TupleClass
+def TupleClass(arity: Int): Symbol
+Function-like object that maps arity to symbols for classes `scala.TupleX`.
+* 0th element is `NoSymbol`
+* 1st element is `NoSymbol`
+* 2st element is `Tuple2`
+* ...
+* 22nd element is `Tuple22`
+* 23nd element is `NoSymbol` // TODO update when we will have more tuples
+* ...
+
+### UnitClass
+def UnitClass: Symbol
+The class symbol of primitive class `scala.Unit`.
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions/StandardTypes.md b/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions/StandardTypes.md
new file mode 100644
index 000000000000..2b30e69f0c3e
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions/StandardTypes.md
@@ -0,0 +1,73 @@
+scala.tasty.reflect.StandardDefinitions
+# trait StandardTypes
+
+trait StandardTypes
+Defines standard types.
+
+***Group*** Definitions
+
+## Concrete Value Members:
+### AnyRefType
+def AnyRefType: Type
+The type of core type `AnyRef`.
+
+### AnyType
+def AnyType: Type
+The type of core type `Any`.
+
+### AnyValType
+def AnyValType: Type
+The type of core type `AnyVal`.
+
+### BooleanType
+def BooleanType: Type
+The type of primitive type `Boolean`.
+
+### ByteType
+def ByteType: Type
+The type of primitive type `Byte`.
+
+### CharType
+def CharType: Type
+The type of primitive type `Char`.
+
+### DoubleType
+def DoubleType: Type
+The type of primitive type `Double`.
+
+### FloatType
+def FloatType: Type
+The type of primitive type `Float`.
+
+### IntType
+def IntType: Type
+The type of primitive type `Int`.
+
+### LongType
+def LongType: Type
+The type of primitive type `Long`.
+
+### NothingType
+def NothingType: Type
+The type of core type `Nothing`.
+
+### NullType
+def NullType: Type
+The type of core type `Null`.
+
+### ObjectType
+def ObjectType: Type
+The type of core type `Object`.
+
+### ShortType
+def ShortType: Type
+The type of primitive type `Short`.
+
+### StringType
+def StringType: Type
+The type for `scala.String`.
+
+### UnitType
+def UnitType: Type
+The type of primitive type `Unit`.
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions/definitions$.md b/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions/definitions$.md
new file mode 100644
index 000000000000..40fd45f6802b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/StandardDefinitions/definitions$.md
@@ -0,0 +1,257 @@
+scala.tasty.reflect.StandardDefinitions
+# object definitions
+
+final object definitions extends StandardSymbols with StandardTypes with Serializable
+A value containing all standard definitions in DefinitionsAPI
+
+***Group*** Definitions
+
+## Concrete Value Members:
+### AnyClass
+def AnyClass: Symbol
+The class symbol of core class `scala.Any`.
+
+### AnyRefClass
+def AnyRefClass: Symbol
+The type symbol of core class `scala.AnyRef`.
+
+### AnyRefType
+def AnyRefType: Type
+The type of core type `AnyRef`.
+
+### AnyType
+def AnyType: Type
+The type of core type `Any`.
+
+### AnyValClass
+def AnyValClass: Symbol
+The class symbol of core class `scala.AnyVal`.
+
+### AnyValType
+def AnyValType: Type
+The type of core type `AnyVal`.
+
+### ArrayClass
+def ArrayClass: Symbol
+The class symbol of class `scala.Array`.
+
+### ArrayModule
+def ArrayModule: Symbol
+The module symbol of module `scala.Array`.
+
+### Array_apply
+def Array_apply: Symbol
+The method symbol of method `apply` in class `scala.Array`.
+
+### Array_clone
+def Array_clone: Symbol
+The method symbol of method `clone` in class `scala.Array`.
+
+### Array_length
+def Array_length: Symbol
+The method symbol of method `length` in class `scala.Array`.
+
+### Array_update
+def Array_update: Symbol
+The method symbol of method `update` in class `scala.Array`.
+
+### BooleanClass
+def BooleanClass: Symbol
+The class symbol of primitive class `scala.Boolean`.
+
+### BooleanType
+def BooleanType: Type
+The type of primitive type `Boolean`.
+
+### ByteClass
+def ByteClass: Symbol
+The class symbol of primitive class `scala.Byte`.
+
+### ByteType
+def ByteType: Type
+The type of primitive type `Byte`.
+
+### CharClass
+def CharClass: Symbol
+The class symbol of primitive class `scala.Char`.
+
+### CharType
+def CharType: Type
+The type of primitive type `Char`.
+
+### ClassClass
+def ClassClass: Symbol
+The class symbol of class `java.lang.Class`.
+
+### DoubleClass
+def DoubleClass: Symbol
+The class symbol of primitive class `scala.Double`.
+
+### DoubleType
+def DoubleType: Type
+The type of primitive type `Double`.
+
+### EmptyPackageClass
+def EmptyPackageClass: Symbol
+The class symbol of empty package `_root_._empty_`.
+
+### FloatClass
+def FloatClass: Symbol
+The class symbol of primitive class `scala.Float`.
+
+### FloatType
+def FloatType: Type
+The type of primitive type `Float`.
+
+### FunctionClass
+def FunctionClass(arity: Int, isImplicit: Boolean, isErased: Boolean): Symbol
+Function-like object that maps arity to symbols for classes `scala.FunctionX`.
+* 0th element is `Function0`
+* 1st element is `Function1`
+* ...
+* Nth element is `FunctionN`
+
+### IntClass
+def IntClass: Symbol
+The class symbol of primitive class `scala.Int`.
+
+### IntType
+def IntType: Type
+The type of primitive type `Int`.
+
+### JavaLangPackage
+def JavaLangPackage: Symbol
+The module symbol of package `java.lang`.
+
+### LongClass
+def LongClass: Symbol
+The class symbol of primitive class `scala.Long`.
+
+### LongType
+def LongType: Type
+The type of primitive type `Long`.
+
+### NoneModule
+def NoneModule: Symbol
+The module symbol of module `scala.None`.
+
+### NothingClass
+def NothingClass: Symbol
+The class symbol of core class `scala.Nothing`.
+
+### NothingType
+def NothingType: Type
+The type of core type `Nothing`.
+
+### NullClass
+def NullClass: Symbol
+The class symbol of core class `scala.Null`.
+
+### NullType
+def NullType: Type
+The type of core type `Null`.
+
+### ObjectClass
+def ObjectClass: Symbol
+The class symbol of core class `java.lang.Object`.
+
+### ObjectType
+def ObjectType: Type
+The type of core type `Object`.
+
+### OptionClass
+def OptionClass: Symbol
+The class symbol of class `scala.Option`.
+
+### PredefModule
+def PredefModule: Symbol
+The module symbol of module `scala.Predef`.
+
+### ProductClass
+def ProductClass: Symbol
+Function-like object that maps arity to symbols for classes `scala.Product`
+
+### RepeatedParamClass
+def RepeatedParamClass: ClassDefSymbol
+A dummy class symbol that is used to indicate repeated parameters
+compiled by the Scala compiler.
+
+### RootClass
+def RootClass: Symbol
+The class symbol of root package `_root_`.
+
+### RootPackage
+def RootPackage: Symbol
+The module symbol of root package `_root_`.
+
+### ScalaNumericValueClasses
+def ScalaNumericValueClasses: List[Symbol]
+Contains Scala numeric value classes:
+* Byte
+* Short
+* Int
+* Long
+* Float
+* Double
+* Char
+
+### ScalaPackage
+def ScalaPackage: Symbol
+The module symbol of package `scala`.
+
+### ScalaPackageClass
+def ScalaPackageClass: Symbol
+The class symbol of package `scala`.
+
+### ScalaPrimitiveValueClasses
+def ScalaPrimitiveValueClasses: List[Symbol]
+Contains Scala primitive value classes:
+* Byte
+* Short
+* Int
+* Long
+* Float
+* Double
+* Char
+* Boolean
+* Unit
+
+### ShortClass
+def ShortClass: Symbol
+The class symbol of primitive class `scala.Short`.
+
+### ShortType
+def ShortType: Type
+The type of primitive type `Short`.
+
+### SomeModule
+def SomeModule: Symbol
+The module symbol of module `scala.Some`.
+
+### StringClass
+def StringClass: Symbol
+The class symbol of class `scala.String`.
+
+### StringType
+def StringType: Type
+The type for `scala.String`.
+
+### TupleClass
+def TupleClass(arity: Int): Symbol
+Function-like object that maps arity to symbols for classes `scala.TupleX`.
+* 0th element is `NoSymbol`
+* 1st element is `NoSymbol`
+* 2st element is `Tuple2`
+* ...
+* 22nd element is `Tuple22`
+* 23nd element is `NoSymbol` // TODO update when we will have more tuples
+* ...
+
+### UnitClass
+def UnitClass: Symbol
+The class symbol of primitive class `scala.Unit`.
+
+### UnitType
+def UnitType: Type
+The type of primitive type `Unit`.
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps.md
new file mode 100644
index 000000000000..9dff60e30501
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps.md
@@ -0,0 +1,45 @@
+scala.tasty.reflect
+# trait SymbolOps
+
+trait SymbolOps extends Core
+Tasty reflect symbol
+
+## Concrete Type Members:
+### ClassDefSymbol
+final object ClassDefSymbol
+### IsBindSymbol
+final object IsBindSymbol
+### IsClassDefSymbol
+final object IsClassDefSymbol
+### IsDefDefSymbol
+final object IsDefDefSymbol
+### IsPackageDefSymbol
+final object IsPackageDefSymbol
+### IsTermSymbol
+final object IsTermSymbol
+### IsTypeBindSymbol
+final object IsTypeBindSymbol
+### IsTypeDefSymbol
+final object IsTypeDefSymbol
+### IsTypeSymbol
+final object IsTypeSymbol
+### IsValDefSymbol
+final object IsValDefSymbol
+### NoSymbol
+final object NoSymbol
+### BindSymbolAPI
+class BindSymbolAPI
+### ClassDefSymbolAPI
+class ClassDefSymbolAPI
+### DefDefSymbolAPI
+class DefDefSymbolAPI
+### PackageDefSymbolAPI
+class PackageDefSymbolAPI
+### SymbolAPI
+class SymbolAPI
+### TypeBindSymbolAPI
+class TypeBindSymbolAPI
+### TypeDefSymbolAPI
+class TypeDefSymbolAPI
+### ValDefSymbolAPI
+class ValDefSymbolAPI
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/BindSymbolAPI.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/BindSymbolAPI.md
new file mode 100644
index 000000000000..02dca4a61c7c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/BindSymbolAPI.md
@@ -0,0 +1,12 @@
+scala.tasty.reflect.SymbolOps
+# class BindSymbolAPI
+
+class BindSymbolAPI
+## Constructors:
+BindSymbolAPI(self: BindSymbol)
+
+## Concrete Value Members:
+### tree
+def tree(implicit ctx: Context): Bind
+Bind pattern of this definition
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/ClassDefSymbol$.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/ClassDefSymbol$.md
new file mode 100644
index 000000000000..86499973f223
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/ClassDefSymbol$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.SymbolOps
+# object ClassDefSymbol
+
+final object ClassDefSymbol extends Serializable
+## Concrete Value Members:
+### of
+def of(fullName: String)(implicit ctx: Context): ClassDefSymbol
+The ClassSymbol of a global class definition
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/ClassDefSymbolAPI.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/ClassDefSymbolAPI.md
new file mode 100644
index 000000000000..bbb393667c35
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/ClassDefSymbolAPI.md
@@ -0,0 +1,52 @@
+scala.tasty.reflect.SymbolOps
+# class ClassDefSymbolAPI
+
+class ClassDefSymbolAPI
+## Constructors:
+ClassDefSymbolAPI(self: ClassDefSymbol)
+
+## Concrete Value Members:
+### caseFields
+def caseFields(implicit ctx: Context): List[ValDefSymbol]
+Fields of a case class type -- only the ones declared in primary constructor
+
+### classMethod
+def classMethod(name: String)(implicit ctx: Context): List[DefDefSymbol]
+Get non-private named methods defined directly inside the class
+
+### classMethods
+def classMethods(implicit ctx: Context): List[DefDefSymbol]
+Get all non-private methods defined directly inside the class, exluding constructors
+
+### companionClass
+def companionClass(implicit ctx: Context): Option[ClassDefSymbol]
+The class symbol of the companion module class
+
+### companionModule
+def companionModule(implicit ctx: Context): Option[ValDefSymbol]
+The symbol of the companion module
+
+### field
+def field(name: String)(implicit ctx: Context): Option[Symbol]
+Field with the given name directly declared in the class
+
+### fields
+def fields(implicit ctx: Context): List[Symbol]
+Fields directly declared in the class
+
+### method
+def method(name: String)(implicit ctx: Context): List[DefDefSymbol]
+Get named non-private methods declared or inherited
+
+### methods
+def methods(implicit ctx: Context): List[DefDefSymbol]
+Get all non-private methods declared or inherited
+
+### moduleClass
+def moduleClass(implicit ctx: Context): Option[Symbol]
+The symbol of the class of the companion module
+
+### tree
+def tree(implicit ctx: Context): ClassDef
+ClassDef tree of this defintion
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/DefDefSymbolAPI.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/DefDefSymbolAPI.md
new file mode 100644
index 000000000000..a49e76a223aa
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/DefDefSymbolAPI.md
@@ -0,0 +1,16 @@
+scala.tasty.reflect.SymbolOps
+# class DefDefSymbolAPI
+
+class DefDefSymbolAPI
+## Constructors:
+DefDefSymbolAPI(self: DefDefSymbol)
+
+## Concrete Value Members:
+### signature
+def signature(implicit ctx: Context): Signature
+Signature of this defintion
+
+### tree
+def tree(implicit ctx: Context): DefDef
+DefDef tree of this defintion
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsBindSymbol$.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsBindSymbol$.md
new file mode 100644
index 000000000000..64138242dd50
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsBindSymbol$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.SymbolOps
+# object IsBindSymbol
+
+final object IsBindSymbol extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(symbol: Symbol)(implicit ctx: Context): Option[BindSymbol]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsClassDefSymbol$.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsClassDefSymbol$.md
new file mode 100644
index 000000000000..b9e7d4afcb9e
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsClassDefSymbol$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.SymbolOps
+# object IsClassDefSymbol
+
+final object IsClassDefSymbol extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(symbol: Symbol)(implicit ctx: Context): Option[ClassDefSymbol]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsDefDefSymbol$.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsDefDefSymbol$.md
new file mode 100644
index 000000000000..396278c651a7
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsDefDefSymbol$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.SymbolOps
+# object IsDefDefSymbol
+
+final object IsDefDefSymbol extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(symbol: Symbol)(implicit ctx: Context): Option[DefDefSymbol]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsPackageDefSymbol$.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsPackageDefSymbol$.md
new file mode 100644
index 000000000000..3ec9dd573ba4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsPackageDefSymbol$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.SymbolOps
+# object IsPackageDefSymbol
+
+final object IsPackageDefSymbol extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(symbol: Symbol)(implicit ctx: Context): Option[PackageDefSymbol]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTermSymbol$.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTermSymbol$.md
new file mode 100644
index 000000000000..fe8ea837f3f2
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTermSymbol$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.SymbolOps
+# object IsTermSymbol
+
+final object IsTermSymbol extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(symbol: Symbol)(implicit ctx: Context): Option[TermSymbol]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTypeBindSymbol$.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTypeBindSymbol$.md
new file mode 100644
index 000000000000..94858410d8d8
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTypeBindSymbol$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.SymbolOps
+# object IsTypeBindSymbol
+
+final object IsTypeBindSymbol extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(symbol: Symbol)(implicit ctx: Context): Option[TypeBindSymbol]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTypeDefSymbol$.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTypeDefSymbol$.md
new file mode 100644
index 000000000000..2841a0035213
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTypeDefSymbol$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.SymbolOps
+# object IsTypeDefSymbol
+
+final object IsTypeDefSymbol extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(symbol: Symbol)(implicit ctx: Context): Option[TypeDefSymbol]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTypeSymbol$.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTypeSymbol$.md
new file mode 100644
index 000000000000..e0705d768537
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsTypeSymbol$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.SymbolOps
+# object IsTypeSymbol
+
+final object IsTypeSymbol extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(symbol: Symbol)(implicit ctx: Context): Option[TypeSymbol]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsValDefSymbol$.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsValDefSymbol$.md
new file mode 100644
index 000000000000..5761c77dfbc0
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/IsValDefSymbol$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.SymbolOps
+# object IsValDefSymbol
+
+final object IsValDefSymbol extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(symbol: Symbol)(implicit ctx: Context): Option[ValDefSymbol]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/NoSymbol$.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/NoSymbol$.md
new file mode 100644
index 000000000000..90f7f746cf7a
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/NoSymbol$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.SymbolOps
+# object NoSymbol
+
+final object NoSymbol extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(symbol: Symbol)(implicit ctx: Context): Boolean
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/PackageDefSymbolAPI.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/PackageDefSymbolAPI.md
new file mode 100644
index 000000000000..f8dd657e671a
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/PackageDefSymbolAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.SymbolOps
+# class PackageDefSymbolAPI
+
+class PackageDefSymbolAPI
+## Constructors:
+PackageDefSymbolAPI(self: PackageDefSymbol)
+
+## Concrete Value Members:
+### tree
+def tree(implicit ctx: Context): PackageDef
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/SymbolAPI.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/SymbolAPI.md
new file mode 100644
index 000000000000..8c4b2bb505fe
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/SymbolAPI.md
@@ -0,0 +1,101 @@
+scala.tasty.reflect.SymbolOps
+# class SymbolAPI
+
+class SymbolAPI
+## Constructors:
+SymbolAPI(self: Symbol)
+
+## Concrete Value Members:
+### annots
+def annots(implicit ctx: Context): List[Term]
+Annotations attached to this symbol
+
+### asBindDef
+def asBindDef(implicit ctx: Context): BindSymbol
+Unsafe cast as to BindSymbol. Use IsBindSymbol to safely check and cast to BindSymbol
+
+### asClassDef
+def asClassDef(implicit ctx: Context): ClassDefSymbol
+Unsafe cast as to ClassSymbol. Use IsClassDefSymbol to safely check and cast to ClassSymbol
+
+### asDefDef
+def asDefDef(implicit ctx: Context): DefDefSymbol
+Unsafe cast as to DefSymbol. Use IsDefDefSymbol to safely check and cast to DefSymbol
+
+### asPackageDef
+def asPackageDef(implicit ctx: Context): PackageDefSymbol
+Unsafe cast as to PackageSymbol. Use IsPackageSymbol to safely check and cast to PackageSymbol
+
+### asTypeDef
+def asTypeDef(implicit ctx: Context): TypeDefSymbol
+Unsafe cast as to TypeSymbol. Use IsTypeDefSymbol to safely check and cast to TypeSymbol
+
+### asValDef
+def asValDef(implicit ctx: Context): ValDefSymbol
+Unsafe cast as to ValSymbol. Use IsValDefSymbol to safely check and cast to ValSymbol
+
+### comment
+def comment(implicit ctx: Context): Option[Comment]
+The comment for this symbol, if any
+
+### flags
+def flags(implicit ctx: Context): Flags
+Flags of this symbol
+
+### fullName
+def fullName(implicit ctx: Context): String
+The full name of this symbol up to the root package
+
+### isAbstractType
+def isAbstractType(implicit ctx: Context): Boolean
+
+### isAliasType
+def isAliasType(implicit ctx: Context): Boolean
+
+### isAnonymousClass
+def isAnonymousClass(implicit ctx: Context): Boolean
+
+### isAnonymousFunction
+def isAnonymousFunction(implicit ctx: Context): Boolean
+
+### isClassConstructor
+def isClassConstructor(implicit ctx: Context): Boolean
+
+### isDefinedInCurrentRun
+def isDefinedInCurrentRun(implicit ctx: Context): Boolean
+
+### isLocalDummy
+def isLocalDummy(implicit ctx: Context): Boolean
+
+### isRefinementClass
+def isRefinementClass(implicit ctx: Context): Boolean
+
+### isTerm
+def isTerm(implicit ctx: Context): Boolean
+
+### isType
+def isType(implicit ctx: Context): Boolean
+
+### localContext
+def localContext(implicit ctx: Context): Context
+
+### name
+def name(implicit ctx: Context): String
+The name of this symbol
+
+### owner
+def owner(implicit ctx: Context): Symbol
+Owner of this symbol. The owner is the symbol in which this symbol is defined
+
+### pos
+def pos(implicit ctx: Context): Position
+The position of this symbol
+
+### privateWithin
+def privateWithin(implicit ctx: Context): Option[Type]
+This symbol is private within the resulting type
+
+### protectedWithin
+def protectedWithin(implicit ctx: Context): Option[Type]
+This symbol is protected within the resulting type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/TypeBindSymbolAPI.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/TypeBindSymbolAPI.md
new file mode 100644
index 000000000000..442e0734b9b4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/TypeBindSymbolAPI.md
@@ -0,0 +1,12 @@
+scala.tasty.reflect.SymbolOps
+# class TypeBindSymbolAPI
+
+class TypeBindSymbolAPI
+## Constructors:
+TypeBindSymbolAPI(self: TypeBindSymbol)
+
+## Concrete Value Members:
+### tree
+def tree(implicit ctx: Context): TypeBind
+TypeBind pattern of this definition
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/TypeDefSymbolAPI.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/TypeDefSymbolAPI.md
new file mode 100644
index 000000000000..bd45fc0814a8
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/TypeDefSymbolAPI.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.SymbolOps
+# class TypeDefSymbolAPI
+
+class TypeDefSymbolAPI
+## Constructors:
+TypeDefSymbolAPI(self: TypeDefSymbol)
+
+## Concrete Value Members:
+### isTypeParam
+def isTypeParam(implicit ctx: Context): Boolean
+
+### tree
+def tree(implicit ctx: Context): TypeDef
+TypeDef tree of this definition
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/SymbolOps/ValDefSymbolAPI.md b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/ValDefSymbolAPI.md
new file mode 100644
index 000000000000..0c8d151f0c50
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/SymbolOps/ValDefSymbolAPI.md
@@ -0,0 +1,19 @@
+scala.tasty.reflect.SymbolOps
+# class ValDefSymbolAPI
+
+class ValDefSymbolAPI
+## Constructors:
+ValDefSymbolAPI(self: ValDefSymbol)
+
+## Concrete Value Members:
+### companionClass
+def companionClass(implicit ctx: Context): Option[ClassDefSymbol]
+
+### moduleClass
+def moduleClass(implicit ctx: Context): Option[ClassDefSymbol]
+The class symbol of the companion module class
+
+### tree
+def tree(implicit ctx: Context): ValDef
+ValDef tree of this defintion
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps.md
new file mode 100644
index 000000000000..aca545a5626b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps.md
@@ -0,0 +1,337 @@
+scala.tasty.reflect
+# trait TreeOps
+
+trait TreeOps extends Core
+## Concrete Type Members:
+### Annotated
+final object Annotated
+### Applied
+final object Applied
+### Apply
+final object Apply
+Scala parameter application
+
+### Assign
+final object Assign
+Scala assign `x = y`
+
+### Block
+final object Block
+Scala code block `{ stat0; ...; statN; expr }` term
+
+### ByName
+final object ByName
+### CaseDef
+final object CaseDef
+### ClassDef
+final object ClassDef
+### DefDef
+final object DefDef
+### Ident
+final object Ident
+Scala term identifier
+
+### If
+final object If
+Scala `if`/`else` term
+
+### ImpliedMatch
+final object ImpliedMatch
+Scala implicit `match` term
+
+### Import
+final object Import
+### Inferred
+final object Inferred
+TypeTree containing an inferred type
+
+### Inlined
+final object Inlined
+### IsAnnotated
+final object IsAnnotated
+### IsApplied
+final object IsApplied
+### IsApply
+final object IsApply
+### IsAssign
+final object IsAssign
+### IsBlock
+final object IsBlock
+### IsByName
+final object IsByName
+### IsCaseDef
+final object IsCaseDef
+### IsClassDef
+final object IsClassDef
+### IsDefDef
+final object IsDefDef
+### IsDefinition
+final object IsDefinition
+### IsIdent
+final object IsIdent
+### IsIf
+final object IsIf
+### IsImplicitMatch
+final object IsImplicitMatch
+### IsImport
+final object IsImport
+### IsInferred
+final object IsInferred
+### IsInlined
+final object IsInlined
+### IsLambda
+final object IsLambda
+### IsLambdaTypeTree
+final object IsLambdaTypeTree
+### IsLiteral
+final object IsLiteral
+### IsMatch
+final object IsMatch
+### IsMatchTypeTree
+final object IsMatchTypeTree
+### IsNamedArg
+final object IsNamedArg
+### IsNew
+final object IsNew
+### IsPackageClause
+final object IsPackageClause
+### IsPackageDef
+final object IsPackageDef
+### IsProjection
+final object IsProjection
+### IsRef
+final object IsRef
+### IsRefined
+final object IsRefined
+### IsRepeated
+final object IsRepeated
+### IsReturn
+final object IsReturn
+### IsSelect
+final object IsSelect
+### IsSelectOuter
+final object IsSelectOuter
+### IsSingleton
+final object IsSingleton
+### IsStatement
+final object IsStatement
+### IsSuper
+final object IsSuper
+### IsTerm
+final object IsTerm
+### IsThis
+final object IsThis
+### IsTry
+final object IsTry
+### IsTypeApply
+final object IsTypeApply
+### IsTypeBind
+final object IsTypeBind
+### IsTypeBlock
+final object IsTypeBlock
+### IsTypeBoundsTree
+final object IsTypeBoundsTree
+### IsTypeCaseDef
+final object IsTypeCaseDef
+### IsTypeDef
+final object IsTypeDef
+### IsTypeIdent
+final object IsTypeIdent
+### IsTypeSelect
+final object IsTypeSelect
+### IsTypeTree
+final object IsTypeTree
+### IsTyped
+final object IsTyped
+### IsValDef
+final object IsValDef
+### IsWhile
+final object IsWhile
+### IsWildcardTypeTree
+final object IsWildcardTypeTree
+### Lambda
+final object Lambda
+### LambdaTypeTree
+final object LambdaTypeTree
+### Literal
+final object Literal
+Scala literal constant
+
+### Match
+final object Match
+Scala `match` term
+
+### MatchTypeTree
+final object MatchTypeTree
+### NamedArg
+final object NamedArg
+Scala named argument `x = y` in argument position
+
+### New
+final object New
+Scala `new`
+
+### PackageClause
+final object PackageClause
+### PackageDef
+final object PackageDef
+### Projection
+final object Projection
+### Ref
+final object Ref
+### Refined
+final object Refined
+### Repeated
+final object Repeated
+### Return
+final object Return
+Scala local `return`
+
+### Select
+final object Select
+Scala term selection
+
+### SelectOuter
+final object SelectOuter
+### Singleton
+final object Singleton
+### Super
+final object Super
+Scala `x.super` or `x.super[id]`
+
+### This
+final object This
+Scala `this` or `this[id]`
+
+### Try
+final object Try
+Scala `try`/`catch`/`finally` term
+
+### TypeApply
+final object TypeApply
+Scala type parameter application
+
+### TypeBind
+final object TypeBind
+### TypeBlock
+final object TypeBlock
+### TypeBoundsTree
+final object TypeBoundsTree
+### TypeCaseDef
+final object TypeCaseDef
+### TypeDef
+final object TypeDef
+### TypeIdent
+final object TypeIdent
+### TypeSelect
+final object TypeSelect
+### Typed
+final object Typed
+Scala ascription `x: T`
+
+### ValDef
+final object ValDef
+### While
+final object While
+### WildcardTypeTree
+final object WildcardTypeTree
+TypeBoundsTree containing wildcard type bounds
+
+### AnnotatedAPI
+class AnnotatedAPI
+### AppliedAPI
+class AppliedAPI
+### ApplyAPI
+class ApplyAPI
+### AssignAPI
+class AssignAPI
+### BlockAPI
+class BlockAPI
+### ByNameAPI
+class ByNameAPI
+### CaseDefAPI
+class CaseDefAPI
+### ClassDefAPI
+class ClassDefAPI
+### DefDefAPI
+class DefDefAPI
+### DefinitionAPI
+class DefinitionAPI
+### IdentAPI
+class IdentAPI
+### IfAPI
+class IfAPI
+### ImplicitMatchAPI
+class ImplicitMatchAPI
+### ImportAPI
+class ImportAPI
+### InlinedAPI
+class InlinedAPI
+### LambdaAPI
+class LambdaAPI
+### LambdaTypeTreeAPI
+class LambdaTypeTreeAPI
+### LiteralAPI
+class LiteralAPI
+### MatchAPI
+class MatchAPI
+### MatchTypeTreeAPI
+class MatchTypeTreeAPI
+### NamedArgAPI
+class NamedArgAPI
+### NewAPI
+class NewAPI
+### PackageClauseAPI
+class PackageClauseAPI
+### PackageDefAPI
+class PackageDefAPI
+### ProjectionAPI
+class ProjectionAPI
+### RefinedAPI
+class RefinedAPI
+### RepeatedAPI
+class RepeatedAPI
+### ReturnAPI
+class ReturnAPI
+### SelectAPI
+class SelectAPI
+### SelectOuterAPI
+class SelectOuterAPI
+### SingletonAPI
+class SingletonAPI
+### SuperAPI
+class SuperAPI
+### TermAPI
+class TermAPI
+### ThisAPI
+class ThisAPI
+### TreeAPI
+class TreeAPI
+### TryAPI
+class TryAPI
+### TypeApplyAPI
+class TypeApplyAPI
+### TypeBindAPI
+class TypeBindAPI
+### TypeBlockAPI
+class TypeBlockAPI
+### TypeBoundsTreeAPI
+class TypeBoundsTreeAPI
+### TypeCaseDefAPI
+class TypeCaseDefAPI
+### TypeDefAPI
+class TypeDefAPI
+### TypeIdentAPI
+class TypeIdentAPI
+### TypeSelectAPI
+class TypeSelectAPI
+### TypeTreeAPI
+class TypeTreeAPI
+### TypedAPI
+class TypedAPI
+### ValDefAPI
+class ValDefAPI
+### WhileAPI
+class WhileAPI
+### WildcardTypeTreeAPI
+class WildcardTypeTreeAPI
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Annotated$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Annotated$.md
new file mode 100644
index 000000000000..b88fcc23d750
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Annotated$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object Annotated
+
+final object Annotated extends Serializable
+## Concrete Value Members:
+### apply
+def apply(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated
+
+### copy
+def copy(original: Annotated)(arg: TypeTree, annotation: Term)(implicit ctx: Context): Annotated
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, Term)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/AnnotatedAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/AnnotatedAPI.md
new file mode 100644
index 000000000000..7117ca211802
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/AnnotatedAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class AnnotatedAPI
+
+class AnnotatedAPI
+## Constructors:
+AnnotatedAPI(self: Annotated)
+
+## Concrete Value Members:
+### annotation
+def annotation(implicit ctx: Context): Term
+
+### arg
+def arg(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Applied$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Applied$.md
new file mode 100644
index 000000000000..a20cc57d37df
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Applied$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object Applied
+
+final object Applied extends Serializable
+## Concrete Value Members:
+### apply
+def apply(tpt: TypeTree, args: List[Tree])(implicit ctx: Context): Applied
+
+### copy
+def copy(original: Applied)(tpt: TypeTree, args: List[Tree])(implicit ctx: Context): Applied
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[Tree])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/AppliedAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/AppliedAPI.md
new file mode 100644
index 000000000000..63d21462a2bf
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/AppliedAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class AppliedAPI
+
+class AppliedAPI
+## Constructors:
+AppliedAPI(self: Applied)
+
+## Concrete Value Members:
+### args
+def args(implicit ctx: Context): List[Tree]
+
+### tpt
+def tpt(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Apply$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Apply$.md
new file mode 100644
index 000000000000..b2af5b1571b4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Apply$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object Apply
+
+final object Apply extends Serializable
+Scala parameter application
+
+## Concrete Value Members:
+### apply
+def apply(fun: Term, args: List[Term])(implicit ctx: Context): Apply
+Create a function application `()`
+
+### copy
+def copy(original: Tree)(fun: Term, args: List[Term])(implicit ctx: Context): Apply
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[Term])]
+Matches a function application `()`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ApplyAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ApplyAPI.md
new file mode 100644
index 000000000000..6c3fdce0eea4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ApplyAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class ApplyAPI
+
+class ApplyAPI
+## Constructors:
+ApplyAPI(self: Apply)
+
+## Concrete Value Members:
+### args
+def args(implicit ctx: Context): List[Term]
+
+### fun
+def fun(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Assign$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Assign$.md
new file mode 100644
index 000000000000..8416ffed02cf
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Assign$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object Assign
+
+final object Assign extends Serializable
+Scala assign `x = y`
+
+## Concrete Value Members:
+### apply
+def apply(lhs: Term, rhs: Term)(implicit ctx: Context): Assign
+Create an assignment ` = `
+
+### copy
+def copy(original: Tree)(lhs: Term, rhs: Term)(implicit ctx: Context): Assign
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)]
+Matches an assignment ` = `
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/AssignAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/AssignAPI.md
new file mode 100644
index 000000000000..fbba6528cefb
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/AssignAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class AssignAPI
+
+class AssignAPI
+## Constructors:
+AssignAPI(self: Assign)
+
+## Concrete Value Members:
+### lhs
+def lhs(implicit ctx: Context): Term
+
+### rhs
+def rhs(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Block$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Block$.md
new file mode 100644
index 000000000000..38375ed06b49
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Block$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object Block
+
+final object Block extends Serializable
+Scala code block `{ stat0; ...; statN; expr }` term
+
+## Concrete Value Members:
+### apply
+def apply(stats: List[Statement], expr: Term)(implicit ctx: Context): Block
+Creates a block `{ ; }`
+
+### copy
+def copy(original: Tree)(stats: List[Statement], expr: Term)(implicit ctx: Context): Block
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(List[Statement], Term)]
+Matches a block `{ ; }`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/BlockAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/BlockAPI.md
new file mode 100644
index 000000000000..e1e756f842e6
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/BlockAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class BlockAPI
+
+class BlockAPI
+## Constructors:
+BlockAPI(self: Block)
+
+## Concrete Value Members:
+### expr
+def expr(implicit ctx: Context): Term
+
+### statements
+def statements(implicit ctx: Context): List[Statement]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ByName$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ByName$.md
new file mode 100644
index 000000000000..8004043eb530
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ByName$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object ByName
+
+final object ByName extends Serializable
+## Concrete Value Members:
+### apply
+def apply(result: TypeTree)(implicit ctx: Context): ByName
+
+### copy
+def copy(original: ByName)(result: TypeTree)(implicit ctx: Context): ByName
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[TypeTree]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ByNameAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ByNameAPI.md
new file mode 100644
index 000000000000..e5a9c7acd9df
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ByNameAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# class ByNameAPI
+
+class ByNameAPI
+## Constructors:
+ByNameAPI(self: ByName)
+
+## Concrete Value Members:
+### result
+def result(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/CaseDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/CaseDef$.md
new file mode 100644
index 000000000000..de110d2a31ad
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/CaseDef$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object CaseDef
+
+final object CaseDef extends Serializable
+## Concrete Value Members:
+### apply
+def apply(pattern: Pattern, guard: Option[Term], rhs: Term)(implicit ctx: Context): CaseDef
+
+### copy
+def copy(original: CaseDef)(pattern: Pattern, guard: Option[Term], rhs: Term)(implicit ctx: Context): CaseDef
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Pattern, Option[Term], Term)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/CaseDefAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/CaseDefAPI.md
new file mode 100644
index 000000000000..4b10c7956efe
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/CaseDefAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# class CaseDefAPI
+
+class CaseDefAPI
+## Constructors:
+CaseDefAPI(caseDef: CaseDef)
+
+## Concrete Value Members:
+### guard
+def guard(implicit ctx: Context): Option[Term]
+
+### pattern
+def pattern(implicit ctx: Context): Pattern
+
+### rhs
+def rhs(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ClassDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ClassDef$.md
new file mode 100644
index 000000000000..bcd68cf6204a
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ClassDef$.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# object ClassDef
+
+final object ClassDef extends Serializable
+## Concrete Value Members:
+### copy
+def copy(original: ClassDef)(name: String, constr: DefDef, parents: List[Tree], derived: List[TypeTree], selfOpt: Option[ValDef], body: List[Statement])(implicit ctx: Context): ClassDef
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(String, DefDef, List[Tree], List[TypeTree], Option[ValDef], List[Statement])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ClassDefAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ClassDefAPI.md
new file mode 100644
index 000000000000..ff1399bb7300
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ClassDefAPI.md
@@ -0,0 +1,26 @@
+scala.tasty.reflect.TreeOps
+# class ClassDefAPI
+
+class ClassDefAPI
+## Constructors:
+ClassDefAPI(self: ClassDef)
+
+## Concrete Value Members:
+### body
+def body(implicit ctx: Context): List[Statement]
+
+### constructor
+def constructor(implicit ctx: Context): DefDef
+
+### derived
+def derived(implicit ctx: Context): List[TypeTree]
+
+### parents
+def parents(implicit ctx: Context): List[Tree]
+
+### self
+def self(implicit ctx: Context): Option[ValDef]
+
+### symbol
+def symbol(implicit ctx: Context): ClassDefSymbol
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/DefDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/DefDef$.md
new file mode 100644
index 000000000000..51739bff1c80
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/DefDef$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object DefDef
+
+final object DefDef extends Serializable
+## Concrete Value Members:
+### apply
+def apply(symbol: DefDefSymbol, rhsFn: (List[Type]) => (List[List[Term]]) => Option[Term])(implicit ctx: Context): DefDef
+
+### copy
+def copy(original: DefDef)(name: String, typeParams: List[TypeDef], paramss: List[List[ValDef]], tpt: TypeTree, rhs: Option[Term])(implicit ctx: Context): DefDef
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(String, List[TypeDef], List[List[ValDef]], TypeTree, Option[Term])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/DefDefAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/DefDefAPI.md
new file mode 100644
index 000000000000..f566d1782cab
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/DefDefAPI.md
@@ -0,0 +1,23 @@
+scala.tasty.reflect.TreeOps
+# class DefDefAPI
+
+class DefDefAPI
+## Constructors:
+DefDefAPI(self: DefDef)
+
+## Concrete Value Members:
+### paramss
+def paramss(implicit ctx: Context): List[List[ValDef]]
+
+### returnTpt
+def returnTpt(implicit ctx: Context): TypeTree
+
+### rhs
+def rhs(implicit ctx: Context): Option[Term]
+
+### symbol
+def symbol(implicit ctx: Context): DefDefSymbol
+
+### typeParams
+def typeParams(implicit ctx: Context): List[TypeDef]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/DefinitionAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/DefinitionAPI.md
new file mode 100644
index 000000000000..293a12a97113
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/DefinitionAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# class DefinitionAPI
+
+class DefinitionAPI
+## Constructors:
+DefinitionAPI(self: Definition)
+
+## Concrete Value Members:
+### name
+def name(implicit ctx: Context): String
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Ident$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Ident$.md
new file mode 100644
index 000000000000..55a391a6f28c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Ident$.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# object Ident
+
+final object Ident extends Serializable
+Scala term identifier
+
+## Concrete Value Members:
+### apply
+def apply(tmref: TermRef)(implicit ctx: Context): Term
+
+### copy
+def copy(original: Tree)(name: String)(implicit ctx: Context): Ident
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[String]
+Matches a term identifier and returns its name
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IdentAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IdentAPI.md
new file mode 100644
index 000000000000..1ca7ef9ef2ac
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IdentAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# class IdentAPI
+
+class IdentAPI
+## Constructors:
+IdentAPI(self: Ident)
+
+## Concrete Value Members:
+### name
+def name(implicit ctx: Context): String
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/If$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/If$.md
new file mode 100644
index 000000000000..148052df29b0
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/If$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object If
+
+final object If extends Serializable
+Scala `if`/`else` term
+
+## Concrete Value Members:
+### apply
+def apply(cond: Term, thenp: Term, elsep: Term)(implicit ctx: Context): If
+Create an if/then/else `if () else `
+
+### copy
+def copy(original: Tree)(cond: Term, thenp: Term, elsep: Term)(implicit ctx: Context): If
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term, Term)]
+Matches an if/then/else `if () else `
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IfAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IfAPI.md
new file mode 100644
index 000000000000..a0273acf7d95
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IfAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# class IfAPI
+
+class IfAPI
+## Constructors:
+IfAPI(self: If)
+
+## Concrete Value Members:
+### cond
+def cond(implicit ctx: Context): Term
+
+### elsep
+def elsep(implicit ctx: Context): Term
+
+### thenp
+def thenp(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ImplicitMatchAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ImplicitMatchAPI.md
new file mode 100644
index 000000000000..11194c112114
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ImplicitMatchAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# class ImplicitMatchAPI
+
+class ImplicitMatchAPI
+## Constructors:
+ImplicitMatchAPI(self: ImpliedMatch)
+
+## Concrete Value Members:
+### cases
+def cases(implicit ctx: Context): List[CaseDef]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ImpliedMatch$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ImpliedMatch$.md
new file mode 100644
index 000000000000..975a1cef1778
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ImpliedMatch$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object ImpliedMatch
+
+final object ImpliedMatch extends Serializable
+Scala implicit `match` term
+
+## Concrete Value Members:
+### apply
+def apply(cases: List[CaseDef])(implicit ctx: Context): ImpliedMatch
+Creates a pattern match `delegate match { }`
+
+### copy
+def copy(original: Tree)(cases: List[CaseDef])(implicit ctx: Context): ImpliedMatch
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[List[CaseDef]]
+Matches a pattern match `delegate match { }`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Import$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Import$.md
new file mode 100644
index 000000000000..d6d5ee9ffdbf
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Import$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object Import
+
+final object Import extends Serializable
+## Concrete Value Members:
+### apply
+def apply(importImplied: Boolean, expr: Term, selectors: List[ImportSelector])(implicit ctx: Context): Import
+
+### copy
+def copy(original: Import)(importImplied: Boolean, expr: Term, selectors: List[ImportSelector])(implicit ctx: Context): Import
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Boolean, Term, List[ImportSelector])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ImportAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ImportAPI.md
new file mode 100644
index 000000000000..e1318eeb64f6
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ImportAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# class ImportAPI
+
+class ImportAPI
+## Constructors:
+ImportAPI(self: Import)
+
+## Concrete Value Members:
+### expr
+def expr(implicit ctx: Context): Term
+
+### importImplied
+def importImplied: Boolean
+
+### selectors
+def selectors(implicit ctx: Context): List[ImportSelector]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Inferred$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Inferred$.md
new file mode 100644
index 000000000000..cf60c3554af9
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Inferred$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object Inferred
+
+final object Inferred extends Serializable
+TypeTree containing an inferred type
+
+## Concrete Value Members:
+### apply
+def apply(tpe: Type)(implicit ctx: Context): Inferred
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Boolean
+Matches a TypeTree containing an inferred type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Inlined$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Inlined$.md
new file mode 100644
index 000000000000..cddb86ca8133
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Inlined$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object Inlined
+
+final object Inlined extends Serializable
+## Concrete Value Members:
+### apply
+def apply(call: Option[Tree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined
+
+### copy
+def copy(original: Tree)(call: Option[Tree], bindings: List[Definition], expansion: Term)(implicit ctx: Context): Inlined
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[Tree], List[Definition], Term)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/InlinedAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/InlinedAPI.md
new file mode 100644
index 000000000000..f559f1ed5011
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/InlinedAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# class InlinedAPI
+
+class InlinedAPI
+## Constructors:
+InlinedAPI(self: Inlined)
+
+## Concrete Value Members:
+### bindings
+def bindings(implicit ctx: Context): List[Definition]
+
+### body
+def body(implicit ctx: Context): Term
+
+### call
+def call(implicit ctx: Context): Option[Tree]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsAnnotated$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsAnnotated$.md
new file mode 100644
index 000000000000..e53f62ce18a0
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsAnnotated$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsAnnotated
+
+final object IsAnnotated extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Annotated]
+Matches any Annotated and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsApplied$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsApplied$.md
new file mode 100644
index 000000000000..338f9d913a44
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsApplied$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsApplied
+
+final object IsApplied extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Applied]
+Matches any Applied and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsApply$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsApply$.md
new file mode 100644
index 000000000000..27194e930a60
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsApply$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsApply
+
+final object IsApply extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Apply]
+Matches any Apply and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsAssign$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsAssign$.md
new file mode 100644
index 000000000000..639a002d3f5f
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsAssign$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsAssign
+
+final object IsAssign extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Assign]
+Matches any Assign and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsBlock$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsBlock$.md
new file mode 100644
index 000000000000..2efe8437b1cb
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsBlock$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsBlock
+
+final object IsBlock extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Block]
+Matches any Block and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsByName$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsByName$.md
new file mode 100644
index 000000000000..b359d1b6e892
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsByName$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsByName
+
+final object IsByName extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[ByName]
+Matches any ByName and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsCaseDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsCaseDef$.md
new file mode 100644
index 000000000000..f1af995bbfe5
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsCaseDef$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsCaseDef
+
+final object IsCaseDef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(self: Tree)(implicit ctx: Context): Option[CaseDef]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsClassDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsClassDef$.md
new file mode 100644
index 000000000000..ae0e6b12e312
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsClassDef$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsClassDef
+
+final object IsClassDef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[ClassDef]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsDefDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsDefDef$.md
new file mode 100644
index 000000000000..929ae1f077fe
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsDefDef$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsDefDef
+
+final object IsDefDef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[DefDef]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsDefinition$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsDefinition$.md
new file mode 100644
index 000000000000..8ff6c15c9e96
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsDefinition$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsDefinition
+
+final object IsDefinition extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Definition]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsIdent$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsIdent$.md
new file mode 100644
index 000000000000..9fcd3ae81e9b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsIdent$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsIdent
+
+final object IsIdent extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Ident]
+Matches any Ident and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsIf$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsIf$.md
new file mode 100644
index 000000000000..8466a21fc18b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsIf$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsIf
+
+final object IsIf extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[If]
+Matches any If and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsImplicitMatch$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsImplicitMatch$.md
new file mode 100644
index 000000000000..a92a89883658
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsImplicitMatch$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsImplicitMatch
+
+final object IsImplicitMatch extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[ImpliedMatch]
+Matches any ImpliedMatch and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsImport$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsImport$.md
new file mode 100644
index 000000000000..6df8a9f451b2
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsImport$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsImport
+
+final object IsImport extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Import]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsInferred$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsInferred$.md
new file mode 100644
index 000000000000..b798ee95b83a
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsInferred$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsInferred
+
+final object IsInferred extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Inferred]
+Matches any Inferred and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsInlined$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsInlined$.md
new file mode 100644
index 000000000000..2d3ef2cd2481
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsInlined$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsInlined
+
+final object IsInlined extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Inlined]
+Matches any Inlined and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsLambda$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsLambda$.md
new file mode 100644
index 000000000000..027d81345c9d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsLambda$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsLambda
+
+final object IsLambda extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Lambda]
+Matches any Lambda and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsLambdaTypeTree$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsLambdaTypeTree$.md
new file mode 100644
index 000000000000..94fb3af14800
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsLambdaTypeTree$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsLambdaTypeTree
+
+final object IsLambdaTypeTree extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[LambdaTypeTree]
+Matches any LambdaTypeTree and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsLiteral$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsLiteral$.md
new file mode 100644
index 000000000000..1e9cea2ce2ae
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsLiteral$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsLiteral
+
+final object IsLiteral extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Literal]
+Matches any Literal and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsMatch$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsMatch$.md
new file mode 100644
index 000000000000..ea66e237e476
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsMatch$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsMatch
+
+final object IsMatch extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Match]
+Matches any Match and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsMatchTypeTree$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsMatchTypeTree$.md
new file mode 100644
index 000000000000..a7bf7d9247ef
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsMatchTypeTree$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsMatchTypeTree
+
+final object IsMatchTypeTree extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[MatchTypeTree]
+Matches any MatchTypeTree and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsNamedArg$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsNamedArg$.md
new file mode 100644
index 000000000000..e78d2a5498c3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsNamedArg$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsNamedArg
+
+final object IsNamedArg extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[NamedArg]
+Matches any NamedArg and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsNew$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsNew$.md
new file mode 100644
index 000000000000..482f365935fb
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsNew$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsNew
+
+final object IsNew extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[New]
+Matches any New and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsPackageClause$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsPackageClause$.md
new file mode 100644
index 000000000000..6af135106ed8
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsPackageClause$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsPackageClause
+
+final object IsPackageClause extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[PackageClause]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsPackageDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsPackageDef$.md
new file mode 100644
index 000000000000..9be3247c6357
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsPackageDef$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsPackageDef
+
+final object IsPackageDef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[PackageDef]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsProjection$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsProjection$.md
new file mode 100644
index 000000000000..36f26b9c3c92
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsProjection$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsProjection
+
+final object IsProjection extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Projection]
+Matches any Projection and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsRef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsRef$.md
new file mode 100644
index 000000000000..61d46092568c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsRef$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsRef
+
+final object IsRef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Ref]
+Matches any Ref and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsRefined$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsRefined$.md
new file mode 100644
index 000000000000..51eaedb423bd
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsRefined$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsRefined
+
+final object IsRefined extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Refined]
+Matches any Refined and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsRepeated$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsRepeated$.md
new file mode 100644
index 000000000000..2fe560640d55
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsRepeated$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsRepeated
+
+final object IsRepeated extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Repeated]
+Matches any Repeated and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsReturn$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsReturn$.md
new file mode 100644
index 000000000000..2e44e12c47c9
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsReturn$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsReturn
+
+final object IsReturn extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Return]
+Matches any Return and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSelect$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSelect$.md
new file mode 100644
index 000000000000..066395cfe124
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSelect$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsSelect
+
+final object IsSelect extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Select]
+Matches any Select and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSelectOuter$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSelectOuter$.md
new file mode 100644
index 000000000000..283bbd82ac67
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSelectOuter$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsSelectOuter
+
+final object IsSelectOuter extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[SelectOuter]
+Matches any SelectOuter and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSingleton$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSingleton$.md
new file mode 100644
index 000000000000..1640f35016af
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSingleton$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsSingleton
+
+final object IsSingleton extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Singleton]
+Matches any Singleton and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsStatement$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsStatement$.md
new file mode 100644
index 000000000000..286805aeb517
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsStatement$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsStatement
+
+final object IsStatement extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Statement]
+Matches any Statement and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSuper$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSuper$.md
new file mode 100644
index 000000000000..3add65f85672
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsSuper$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsSuper
+
+final object IsSuper extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Super]
+Matches any Super and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTerm$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTerm$.md
new file mode 100644
index 000000000000..0c75ee2cc2ab
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTerm$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsTerm
+
+final object IsTerm extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Term]
+Matches any term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsThis$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsThis$.md
new file mode 100644
index 000000000000..2c6c0efaac55
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsThis$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsThis
+
+final object IsThis extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[This]
+Matches any This and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTry$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTry$.md
new file mode 100644
index 000000000000..7753fb407992
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTry$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsTry
+
+final object IsTry extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Try]
+Matches any Try and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeApply$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeApply$.md
new file mode 100644
index 000000000000..a602732c6743
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeApply$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsTypeApply
+
+final object IsTypeApply extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[TypeApply]
+Matches any TypeApply and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeBind$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeBind$.md
new file mode 100644
index 000000000000..814fa8d34e96
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeBind$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsTypeBind
+
+final object IsTypeBind extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBind]
+Matches any TypeBind and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeBlock$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeBlock$.md
new file mode 100644
index 000000000000..8760833ef5b7
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeBlock$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsTypeBlock
+
+final object IsTypeBlock extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBlock]
+Matches any TypeBlock and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeBoundsTree$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeBoundsTree$.md
new file mode 100644
index 000000000000..5ccc6f61c411
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeBoundsTree$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsTypeBoundsTree
+
+final object IsTypeBoundsTree extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[TypeBoundsTree]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeCaseDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeCaseDef$.md
new file mode 100644
index 000000000000..ee13ecc156b7
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeCaseDef$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsTypeCaseDef
+
+final object IsTypeCaseDef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(self: Tree)(implicit ctx: Context): Option[TypeCaseDef]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeDef$.md
new file mode 100644
index 000000000000..98289c0ff8be
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeDef$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsTypeDef
+
+final object IsTypeDef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[TypeDef]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeIdent$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeIdent$.md
new file mode 100644
index 000000000000..2231e1e113cf
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeIdent$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsTypeIdent
+
+final object IsTypeIdent extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[TypeIdent]
+Matches any TypeIdent and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeSelect$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeSelect$.md
new file mode 100644
index 000000000000..fe854f5cc619
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeSelect$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsTypeSelect
+
+final object IsTypeSelect extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[TypeSelect]
+Matches any TypeSelect and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeTree$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeTree$.md
new file mode 100644
index 000000000000..b02e5ebfce23
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTypeTree$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsTypeTree
+
+final object IsTypeTree extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpt: Tree)(implicit ctx: Context): Option[TypeTree]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTyped$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTyped$.md
new file mode 100644
index 000000000000..b613a6259dd0
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsTyped$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsTyped
+
+final object IsTyped extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Typed]
+Matches any Typed and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsValDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsValDef$.md
new file mode 100644
index 000000000000..e31f902592c7
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsValDef$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsValDef
+
+final object IsValDef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[ValDef]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsWhile$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsWhile$.md
new file mode 100644
index 000000000000..fff5ee9fd213
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsWhile$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object IsWhile
+
+final object IsWhile extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[While]
+Matches any While and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsWildcardTypeTree$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsWildcardTypeTree$.md
new file mode 100644
index 000000000000..eb3a84be50bd
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/IsWildcardTypeTree$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object IsWildcardTypeTree
+
+final object IsWildcardTypeTree extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[WildcardTypeTree]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Lambda$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Lambda$.md
new file mode 100644
index 000000000000..f514f2e62d81
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Lambda$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object Lambda
+
+final object Lambda extends Serializable
+## Concrete Value Members:
+### apply
+def apply(meth: Term, tpt: Option[TypeTree])(implicit ctx: Context): Lambda
+
+### copy
+def copy(original: Tree)(meth: Tree, tpt: Option[TypeTree])(implicit ctx: Context): Lambda
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Option[TypeTree])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/LambdaAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/LambdaAPI.md
new file mode 100644
index 000000000000..addce4457da8
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/LambdaAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class LambdaAPI
+
+class LambdaAPI
+## Constructors:
+LambdaAPI(self: Lambda)
+
+## Concrete Value Members:
+### meth
+def meth(implicit ctx: Context): Term
+
+### tptOpt
+def tptOpt(implicit ctx: Context): Option[TypeTree]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/LambdaTypeTree$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/LambdaTypeTree$.md
new file mode 100644
index 000000000000..d08797f074b3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/LambdaTypeTree$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object LambdaTypeTree
+
+final object LambdaTypeTree extends Serializable
+## Concrete Value Members:
+### apply
+def apply(tparams: List[TypeDef], body: Tree)(implicit ctx: Context): LambdaTypeTree
+
+### copy
+def copy(original: LambdaTypeTree)(tparams: List[TypeDef], body: Tree)(implicit ctx: Context): LambdaTypeTree
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], Tree)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/LambdaTypeTreeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/LambdaTypeTreeAPI.md
new file mode 100644
index 000000000000..8932e3d5f644
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/LambdaTypeTreeAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class LambdaTypeTreeAPI
+
+class LambdaTypeTreeAPI
+## Constructors:
+LambdaTypeTreeAPI(self: LambdaTypeTree)
+
+## Concrete Value Members:
+### body
+def body(implicit ctx: Context): Tree
+
+### tparams
+def tparams(implicit ctx: Context): List[TypeDef]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Literal$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Literal$.md
new file mode 100644
index 000000000000..654fd58c1bb9
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Literal$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object Literal
+
+final object Literal extends Serializable
+Scala literal constant
+
+## Concrete Value Members:
+### apply
+def apply(constant: Constant)(implicit ctx: Context): Literal
+Create a literal constant
+
+### copy
+def copy(original: Tree)(constant: Constant)(implicit ctx: Context): Literal
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Constant]
+Matches a literal constant
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/LiteralAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/LiteralAPI.md
new file mode 100644
index 000000000000..2fd60f37b6ca
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/LiteralAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# class LiteralAPI
+
+class LiteralAPI
+## Constructors:
+LiteralAPI(self: Literal)
+
+## Concrete Value Members:
+### constant
+def constant(implicit ctx: Context): Constant
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Match$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Match$.md
new file mode 100644
index 000000000000..87c44993a390
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Match$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object Match
+
+final object Match extends Serializable
+Scala `match` term
+
+## Concrete Value Members:
+### apply
+def apply(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match
+Creates a pattern match ` match { }`
+
+### copy
+def copy(original: Tree)(selector: Term, cases: List[CaseDef])(implicit ctx: Context): Match
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[CaseDef])]
+Matches a pattern match ` match { }`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/MatchAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/MatchAPI.md
new file mode 100644
index 000000000000..ec71ceec53ee
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/MatchAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class MatchAPI
+
+class MatchAPI
+## Constructors:
+MatchAPI(self: Match)
+
+## Concrete Value Members:
+### cases
+def cases(implicit ctx: Context): List[CaseDef]
+
+### scrutinee
+def scrutinee(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/MatchTypeTree$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/MatchTypeTree$.md
new file mode 100644
index 000000000000..69501db100f3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/MatchTypeTree$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object MatchTypeTree
+
+final object MatchTypeTree extends Serializable
+## Concrete Value Members:
+### apply
+def apply(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchTypeTree
+
+### copy
+def copy(original: MatchTypeTree)(bound: Option[TypeTree], selector: TypeTree, cases: List[TypeCaseDef])(implicit ctx: Context): MatchTypeTree
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Option[TypeTree], TypeTree, List[TypeCaseDef])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/MatchTypeTreeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/MatchTypeTreeAPI.md
new file mode 100644
index 000000000000..c414a91f327d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/MatchTypeTreeAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# class MatchTypeTreeAPI
+
+class MatchTypeTreeAPI
+## Constructors:
+MatchTypeTreeAPI(self: MatchTypeTree)
+
+## Concrete Value Members:
+### bound
+def bound(implicit ctx: Context): Option[TypeTree]
+
+### cases
+def cases(implicit ctx: Context): List[TypeCaseDef]
+
+### selector
+def selector(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/NamedArg$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/NamedArg$.md
new file mode 100644
index 000000000000..93c04cc1ff46
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/NamedArg$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object NamedArg
+
+final object NamedArg extends Serializable
+Scala named argument `x = y` in argument position
+
+## Concrete Value Members:
+### apply
+def apply(name: String, arg: Term)(implicit ctx: Context): NamedArg
+Create a named argument ` = `
+
+### copy
+def copy(original: NamedArg)(name: String, arg: Term)(implicit ctx: Context): NamedArg
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(String, Term)]
+Matches a named argument ` = `
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/NamedArgAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/NamedArgAPI.md
new file mode 100644
index 000000000000..7c176717ed1a
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/NamedArgAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class NamedArgAPI
+
+class NamedArgAPI
+## Constructors:
+NamedArgAPI(self: NamedArg)
+
+## Concrete Value Members:
+### name
+def name(implicit ctx: Context): String
+
+### value
+def value(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/New$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/New$.md
new file mode 100644
index 000000000000..a7823f08a285
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/New$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object New
+
+final object New extends Serializable
+Scala `new`
+
+## Concrete Value Members:
+### apply
+def apply(tpt: TypeTree)(implicit ctx: Context): New
+Create a `new `
+
+### copy
+def copy(original: Tree)(tpt: TypeTree)(implicit ctx: Context): New
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[TypeTree]
+Matches a `new `
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/NewAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/NewAPI.md
new file mode 100644
index 000000000000..237ee24c5c81
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/NewAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# class NewAPI
+
+class NewAPI
+## Constructors:
+NewAPI(self: New)
+
+## Concrete Value Members:
+### tpt
+def tpt(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageClause$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageClause$.md
new file mode 100644
index 000000000000..5dcba3fd3cc0
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageClause$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object PackageClause
+
+final object PackageClause extends Serializable
+## Concrete Value Members:
+### apply
+def apply(pid: Ref, stats: List[Tree])(implicit ctx: Context): PackageClause
+
+### copy
+def copy(original: PackageClause)(pid: Ref, stats: List[Tree])(implicit ctx: Context): PackageClause
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Ref, List[Tree])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageClauseAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageClauseAPI.md
new file mode 100644
index 000000000000..546062bcae8c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageClauseAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class PackageClauseAPI
+
+class PackageClauseAPI
+## Constructors:
+PackageClauseAPI(self: PackageClause)
+
+## Concrete Value Members:
+### pid
+def pid(implicit ctx: Context): Ref
+
+### stats
+def stats(implicit ctx: Context): List[Tree]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageDef$.md
new file mode 100644
index 000000000000..ec14a376d05b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageDef$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object PackageDef
+
+final object PackageDef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(String, PackageDef)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageDefAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageDefAPI.md
new file mode 100644
index 000000000000..248bd3ef4568
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/PackageDefAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# class PackageDefAPI
+
+class PackageDefAPI
+## Constructors:
+PackageDefAPI(self: PackageDef)
+
+## Concrete Value Members:
+### members
+def members(implicit ctx: Context): List[Statement]
+
+### owner
+def owner(implicit ctx: Context): PackageDef
+
+### symbol
+def symbol(implicit ctx: Context): PackageDefSymbol
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Projection$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Projection$.md
new file mode 100644
index 000000000000..d517c7a8a5aa
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Projection$.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# object Projection
+
+final object Projection extends Serializable
+## Concrete Value Members:
+### copy
+def copy(original: Projection)(qualifier: TypeTree, name: String)(implicit ctx: Context): Projection
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, String)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ProjectionAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ProjectionAPI.md
new file mode 100644
index 000000000000..5a11774b5b90
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ProjectionAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class ProjectionAPI
+
+class ProjectionAPI
+## Constructors:
+ProjectionAPI(self: Projection)
+
+## Concrete Value Members:
+### name
+def name(implicit ctx: Context): String
+
+### qualifier
+def qualifier(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Ref$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Ref$.md
new file mode 100644
index 000000000000..2a9e63e49695
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Ref$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TreeOps
+# object Ref
+
+final object Ref extends Serializable
+## Concrete Value Members:
+### apply
+def apply(sym: Symbol)(implicit ctx: Context): Ref
+Create a reference tree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Refined$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Refined$.md
new file mode 100644
index 000000000000..b2b949e8b74d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Refined$.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# object Refined
+
+final object Refined extends Serializable
+## Concrete Value Members:
+### copy
+def copy(original: Refined)(tpt: TypeTree, refinements: List[Definition])(implicit ctx: Context): Refined
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, List[Definition])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/RefinedAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/RefinedAPI.md
new file mode 100644
index 000000000000..ad1b4ff580a8
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/RefinedAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class RefinedAPI
+
+class RefinedAPI
+## Constructors:
+RefinedAPI(self: Refined)
+
+## Concrete Value Members:
+### refinements
+def refinements(implicit ctx: Context): List[Definition]
+
+### tpt
+def tpt(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Repeated$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Repeated$.md
new file mode 100644
index 000000000000..4a30062f2740
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Repeated$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object Repeated
+
+final object Repeated extends Serializable
+## Concrete Value Members:
+### apply
+def apply(elems: List[Term], tpt: TypeTree)(implicit ctx: Context): Repeated
+
+### copy
+def copy(original: Tree)(elems: List[Term], tpt: TypeTree)(implicit ctx: Context): Repeated
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(List[Term], TypeTree)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/RepeatedAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/RepeatedAPI.md
new file mode 100644
index 000000000000..98a34f16ce80
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/RepeatedAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class RepeatedAPI
+
+class RepeatedAPI
+## Constructors:
+RepeatedAPI(self: Repeated)
+
+## Concrete Value Members:
+### elems
+def elems(implicit ctx: Context): List[Term]
+
+### elemtpt
+def elemtpt(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Return$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Return$.md
new file mode 100644
index 000000000000..314d20bbacf4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Return$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object Return
+
+final object Return extends Serializable
+Scala local `return`
+
+## Concrete Value Members:
+### apply
+def apply(expr: Term)(implicit ctx: Context): Return
+Creates `return `
+
+### copy
+def copy(original: Tree)(expr: Term)(implicit ctx: Context): Return
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Term]
+Matches `return `
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ReturnAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ReturnAPI.md
new file mode 100644
index 000000000000..f3de3cd9e662
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ReturnAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# class ReturnAPI
+
+class ReturnAPI
+## Constructors:
+ReturnAPI(self: Return)
+
+## Concrete Value Members:
+### expr
+def expr(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Select$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Select$.md
new file mode 100644
index 000000000000..025ef0757208
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Select$.md
@@ -0,0 +1,30 @@
+scala.tasty.reflect.TreeOps
+# object Select
+
+final object Select extends Serializable
+Scala term selection
+
+## Concrete Value Members:
+### apply
+def apply(qualifier: Term, symbol: Symbol)(implicit ctx: Context): Select
+Select a term member by symbol
+
+### copy
+def copy(original: Tree)(qualifier: Term, name: String)(implicit ctx: Context): Select
+
+### overloaded
+def overloaded(qualifier: Term, name: String, targs: List[Type], args: List[Term])(implicit ctx: Context): Apply
+Call an overloaded method with the given type and term parameters
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, String)]
+Matches `.`
+
+### unique
+def unique(qualifier: Term, name: String)(implicit ctx: Context): Select
+Select a field or a non-overloaded method by name
+
+***Note*** The method will produce an assertion error if the selected
+ method is overloaded. The method `overloaded` should be used
+ in that case.
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/SelectAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/SelectAPI.md
new file mode 100644
index 000000000000..6b2d193a1c20
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/SelectAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# class SelectAPI
+
+class SelectAPI
+## Constructors:
+SelectAPI(self: Select)
+
+## Concrete Value Members:
+### name
+def name(implicit ctx: Context): String
+
+### qualifier
+def qualifier(implicit ctx: Context): Term
+
+### signature
+def signature(implicit ctx: Context): Option[Signature]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/SelectOuter$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/SelectOuter$.md
new file mode 100644
index 000000000000..13320a69d333
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/SelectOuter$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object SelectOuter
+
+final object SelectOuter extends Serializable
+## Concrete Value Members:
+### apply
+def apply(qualifier: Term, name: String, levels: Int)(implicit ctx: Context): SelectOuter
+
+### copy
+def copy(original: Tree)(qualifier: Term, name: String, levels: Int)(implicit ctx: Context): SelectOuter
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Int, Type)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/SelectOuterAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/SelectOuterAPI.md
new file mode 100644
index 000000000000..6b780228eee2
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/SelectOuterAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# class SelectOuterAPI
+
+class SelectOuterAPI
+## Constructors:
+SelectOuterAPI(self: SelectOuter)
+
+## Concrete Value Members:
+### level
+def level(implicit ctx: Context): Int
+
+### qualifier
+def qualifier(implicit ctx: Context): Term
+
+### tpe
+def tpe(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Singleton$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Singleton$.md
new file mode 100644
index 000000000000..c24b5284588f
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Singleton$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object Singleton
+
+final object Singleton extends Serializable
+## Concrete Value Members:
+### apply
+def apply(ref: Term)(implicit ctx: Context): Singleton
+
+### copy
+def copy(original: Singleton)(ref: Term)(implicit ctx: Context): Singleton
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Term]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/SingletonAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/SingletonAPI.md
new file mode 100644
index 000000000000..bce889f0cce8
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/SingletonAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# class SingletonAPI
+
+class SingletonAPI
+## Constructors:
+SingletonAPI(self: Singleton)
+
+## Concrete Value Members:
+### ref
+def ref(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Super$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Super$.md
new file mode 100644
index 000000000000..0fc06bc878aa
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Super$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object Super
+
+final object Super extends Serializable
+Scala `x.super` or `x.super[id]`
+
+## Concrete Value Members:
+### apply
+def apply(qual: Term, mix: Option[Id])(implicit ctx: Context): Super
+Creates a `.super[`
+
+### copy
+def copy(original: Tree)(qual: Term, mix: Option[Id])(implicit ctx: Context): Super
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Option[Id])]
+Matches a `.super[`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/SuperAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/SuperAPI.md
new file mode 100644
index 000000000000..03198e54cf8c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/SuperAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class SuperAPI
+
+class SuperAPI
+## Constructors:
+SuperAPI(self: Super)
+
+## Concrete Value Members:
+### id
+def id(implicit ctx: Context): Option[Id]
+
+### qualifier
+def qualifier(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TermAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TermAPI.md
new file mode 100644
index 000000000000..256f99fc3674
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TermAPI.md
@@ -0,0 +1,57 @@
+scala.tasty.reflect.TreeOps
+# class TermAPI
+
+class TermAPI
+## Constructors:
+TermAPI(self: Term)
+
+## Concrete Value Members:
+### appliedTo
+def appliedTo(arg: Term, args: Seq[Term])(implicit ctx: Context): Term
+An apply node with given arguments: `tree(arg, args0, ..., argsN)`
+
+### appliedTo
+def appliedTo(arg: Term)(implicit ctx: Context): Term
+A unary apply node with given argument: `tree(arg)`
+
+### appliedToArgs
+def appliedToArgs(args: List[Term])(implicit ctx: Context): Apply
+An apply node with given argument list `tree(args(0), ..., args(args.length - 1))`
+
+### appliedToArgss
+def appliedToArgss(argss: List[List[Term]])(implicit ctx: Context): Term
+The current tree applied to given argument lists:
+`tree (argss(0)) ... (argss(argss.length -1))`
+
+### appliedToNone
+def appliedToNone(implicit ctx: Context): Apply
+The current tree applied to (): `tree()`
+
+### appliedToType
+def appliedToType(targ: Type)(implicit ctx: Context): Term
+The current tree applied to given type argument: `tree[targ]`
+
+### appliedToTypeTrees
+def appliedToTypeTrees(targs: List[TypeTree])(implicit ctx: Context): Term
+The current tree applied to given type argument list: `tree[targs(0), ..., targs(targs.length - 1)]`
+
+### appliedToTypes
+def appliedToTypes(targs: List[Type])(implicit ctx: Context): Term
+The current tree applied to given type arguments: `tree[targ0, ..., targN]`
+
+### pos
+def pos(implicit ctx: Context): Position
+
+### select
+def select(sym: Symbol)(implicit ctx: Context): Select
+A select node that selects the given symbol.
+
+### tpe
+def tpe(implicit ctx: Context): Type
+
+### underlying
+def underlying(implicit ctx: Context): Term
+
+### underlyingArgument
+def underlyingArgument(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/This$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/This$.md
new file mode 100644
index 000000000000..352934fe42c4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/This$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object This
+
+final object This extends Serializable
+Scala `this` or `this[id]`
+
+## Concrete Value Members:
+### apply
+def apply(cls: ClassDefSymbol)(implicit ctx: Context): This
+Create a `this[`
+
+### copy
+def copy(original: Tree)(qual: Option[Id])(implicit ctx: Context): This
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[Option[Id]]
+Matches `this[`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ThisAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ThisAPI.md
new file mode 100644
index 000000000000..597de2d5dd29
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ThisAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# class ThisAPI
+
+class ThisAPI
+## Constructors:
+ThisAPI(self: This)
+
+## Concrete Value Members:
+### id
+def id(implicit ctx: Context): Option[Id]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TreeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TreeAPI.md
new file mode 100644
index 000000000000..eb5f0ed18b1d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TreeAPI.md
@@ -0,0 +1,15 @@
+scala.tasty.reflect.TreeOps
+# class TreeAPI
+
+class TreeAPI
+## Constructors:
+TreeAPI(self: Tree)
+
+## Concrete Value Members:
+### pos
+def pos(implicit ctx: Context): Position
+Position in the source code
+
+### symbol
+def symbol(implicit ctx: Context): Symbol
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Try$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Try$.md
new file mode 100644
index 000000000000..9f2d83bcfbc0
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Try$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object Try
+
+final object Try extends Serializable
+Scala `try`/`catch`/`finally` term
+
+## Concrete Value Members:
+### apply
+def apply(expr: Term, cases: List[CaseDef], finalizer: Option[Term])(implicit ctx: Context): Try
+Create a try/catch `try catch { } finally `
+
+### copy
+def copy(original: Tree)(expr: Term, cases: List[CaseDef], finalizer: Option[Term])(implicit ctx: Context): Try
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[CaseDef], Option[Term])]
+Matches a try/catch `try catch { } finally `
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TryAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TryAPI.md
new file mode 100644
index 000000000000..7756cf6a0086
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TryAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# class TryAPI
+
+class TryAPI
+## Constructors:
+TryAPI(self: Try)
+
+## Concrete Value Members:
+### body
+def body(implicit ctx: Context): Term
+
+### cases
+def cases(implicit ctx: Context): List[CaseDef]
+
+### finalizer
+def finalizer(implicit ctx: Context): Option[Term]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeApply$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeApply$.md
new file mode 100644
index 000000000000..8cba50816ac9
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeApply$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object TypeApply
+
+final object TypeApply extends Serializable
+Scala type parameter application
+
+## Concrete Value Members:
+### apply
+def apply(fun: Term, args: List[TypeTree])(implicit ctx: Context): TypeApply
+Create a function type application `[]`
+
+### copy
+def copy(original: Tree)(fun: Term, args: List[TypeTree])(implicit ctx: Context): TypeApply
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, List[TypeTree])]
+Matches a function type application `[]`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeApplyAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeApplyAPI.md
new file mode 100644
index 000000000000..531e8a9db3b4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeApplyAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class TypeApplyAPI
+
+class TypeApplyAPI
+## Constructors:
+TypeApplyAPI(self: TypeApply)
+
+## Concrete Value Members:
+### args
+def args(implicit ctx: Context): List[TypeTree]
+
+### fun
+def fun(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBind$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBind$.md
new file mode 100644
index 000000000000..3630d6eab8f2
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBind$.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# object TypeBind
+
+final object TypeBind extends Serializable
+## Concrete Value Members:
+### copy
+def copy(original: TypeBind)(name: String, tpt: Tree)(implicit ctx: Context): TypeBind
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(String, Tree)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBindAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBindAPI.md
new file mode 100644
index 000000000000..b2d7134dd4b8
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBindAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class TypeBindAPI
+
+class TypeBindAPI
+## Constructors:
+TypeBindAPI(self: TypeBind)
+
+## Concrete Value Members:
+### body
+def body(implicit ctx: Context): Tree
+
+### name
+def name(implicit ctx: Context): String
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBlock$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBlock$.md
new file mode 100644
index 000000000000..4377d1bfced9
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBlock$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object TypeBlock
+
+final object TypeBlock extends Serializable
+## Concrete Value Members:
+### apply
+def apply(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock
+
+### copy
+def copy(original: TypeBlock)(aliases: List[TypeDef], tpt: TypeTree)(implicit ctx: Context): TypeBlock
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(List[TypeDef], TypeTree)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBlockAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBlockAPI.md
new file mode 100644
index 000000000000..fb47f277c76e
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBlockAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class TypeBlockAPI
+
+class TypeBlockAPI
+## Constructors:
+TypeBlockAPI(self: TypeBlock)
+
+## Concrete Value Members:
+### aliases
+def aliases(implicit ctx: Context): List[TypeDef]
+
+### tpt
+def tpt(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBoundsTree$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBoundsTree$.md
new file mode 100644
index 000000000000..41d5db7e07f4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBoundsTree$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TreeOps
+# object TypeBoundsTree
+
+final object TypeBoundsTree extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, TypeTree)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBoundsTreeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBoundsTreeAPI.md
new file mode 100644
index 000000000000..c425ab61225b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeBoundsTreeAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# class TypeBoundsTreeAPI
+
+class TypeBoundsTreeAPI
+## Constructors:
+TypeBoundsTreeAPI(self: TypeBoundsTree)
+
+## Concrete Value Members:
+### hi
+def hi(implicit ctx: Context): TypeTree
+
+### low
+def low(implicit ctx: Context): TypeTree
+
+### tpe
+def tpe(implicit ctx: Context): TypeBounds
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeCaseDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeCaseDef$.md
new file mode 100644
index 000000000000..bb631202722c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeCaseDef$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object TypeCaseDef
+
+final object TypeCaseDef extends Serializable
+## Concrete Value Members:
+### apply
+def apply(pattern: TypeTree, rhs: TypeTree)(implicit ctx: Context): TypeCaseDef
+
+### copy
+def copy(original: TypeCaseDef)(pattern: TypeTree, rhs: TypeTree)(implicit ctx: Context): TypeCaseDef
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(TypeTree, TypeTree)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeCaseDefAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeCaseDefAPI.md
new file mode 100644
index 000000000000..112bcc08151e
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeCaseDefAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class TypeCaseDefAPI
+
+class TypeCaseDefAPI
+## Constructors:
+TypeCaseDefAPI(caseDef: TypeCaseDef)
+
+## Concrete Value Members:
+### pattern
+def pattern(implicit ctx: Context): TypeTree
+
+### rhs
+def rhs(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeDef$.md
new file mode 100644
index 000000000000..36a4d5ae5efa
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeDef$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object TypeDef
+
+final object TypeDef extends Serializable
+## Concrete Value Members:
+### apply
+def apply(symbol: TypeDefSymbol)(implicit ctx: Context): TypeDef
+
+### copy
+def copy(original: TypeDef)(name: String, rhs: Tree)(implicit ctx: Context): TypeDef
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(String, Tree)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeDefAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeDefAPI.md
new file mode 100644
index 000000000000..905427683647
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeDefAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class TypeDefAPI
+
+class TypeDefAPI
+## Constructors:
+TypeDefAPI(self: TypeDef)
+
+## Concrete Value Members:
+### rhs
+def rhs(implicit ctx: Context): Tree
+
+### symbol
+def symbol(implicit ctx: Context): TypeDefSymbol
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeIdent$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeIdent$.md
new file mode 100644
index 000000000000..3f3a60f8c393
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeIdent$.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# object TypeIdent
+
+final object TypeIdent extends Serializable
+## Concrete Value Members:
+### copy
+def copy(original: TypeIdent)(name: String)(implicit ctx: Context): TypeIdent
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[String]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeIdentAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeIdentAPI.md
new file mode 100644
index 000000000000..b825a0a09eb3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeIdentAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# class TypeIdentAPI
+
+class TypeIdentAPI
+## Constructors:
+TypeIdentAPI(self: TypeIdent)
+
+## Concrete Value Members:
+### name
+def name(implicit ctx: Context): String
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeSelect$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeSelect$.md
new file mode 100644
index 000000000000..cb3ed392932d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeSelect$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object TypeSelect
+
+final object TypeSelect extends Serializable
+## Concrete Value Members:
+### apply
+def apply(qualifier: Term, name: String)(implicit ctx: Context): TypeSelect
+
+### copy
+def copy(original: TypeSelect)(qualifier: Term, name: String)(implicit ctx: Context): TypeSelect
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, String)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeSelectAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeSelectAPI.md
new file mode 100644
index 000000000000..d495a0976baf
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeSelectAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class TypeSelectAPI
+
+class TypeSelectAPI
+## Constructors:
+TypeSelectAPI(self: TypeSelect)
+
+## Concrete Value Members:
+### name
+def name(implicit ctx: Context): String
+
+### qualifier
+def qualifier(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeTreeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeTreeAPI.md
new file mode 100644
index 000000000000..99e8b04b09bc
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypeTreeAPI.md
@@ -0,0 +1,20 @@
+scala.tasty.reflect.TreeOps
+# class TypeTreeAPI
+
+class TypeTreeAPI
+## Constructors:
+TypeTreeAPI(self: TypeTree)
+
+## Concrete Value Members:
+### pos
+def pos(implicit ctx: Context): Position
+Position in the source code
+
+### symbol
+def symbol(implicit ctx: Context): Symbol
+Symbol of this type tree
+
+### tpe
+def tpe(implicit ctx: Context): Type
+Type of this type tree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/Typed$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Typed$.md
new file mode 100644
index 000000000000..454197e68578
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/Typed$.md
@@ -0,0 +1,18 @@
+scala.tasty.reflect.TreeOps
+# object Typed
+
+final object Typed extends Serializable
+Scala ascription `x: T`
+
+## Concrete Value Members:
+### apply
+def apply(expr: Term, tpt: TypeTree)(implicit ctx: Context): Typed
+Create a type ascription `: `
+
+### copy
+def copy(original: Tree)(expr: Term, tpt: TypeTree)(implicit ctx: Context): Typed
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, TypeTree)]
+Matches `: `
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypedAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypedAPI.md
new file mode 100644
index 000000000000..72286b234b0e
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/TypedAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class TypedAPI
+
+class TypedAPI
+## Constructors:
+TypedAPI(self: Typed)
+
+## Concrete Value Members:
+### expr
+def expr(implicit ctx: Context): Term
+
+### tpt
+def tpt(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ValDef$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ValDef$.md
new file mode 100644
index 000000000000..1f9052ea9cdd
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ValDef$.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# object ValDef
+
+final object ValDef extends Serializable
+## Concrete Value Members:
+### apply
+def apply(symbol: ValDefSymbol, rhs: Option[Term])(implicit ctx: Context): ValDef
+
+### copy
+def copy(original: ValDef)(name: String, tpt: TypeTree, rhs: Option[Term])(implicit ctx: Context): ValDef
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(String, TypeTree, Option[Term])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/ValDefAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ValDefAPI.md
new file mode 100644
index 000000000000..6e07ef9a9cb5
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/ValDefAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TreeOps
+# class ValDefAPI
+
+class ValDefAPI
+## Constructors:
+ValDefAPI(self: ValDef)
+
+## Concrete Value Members:
+### rhs
+def rhs(implicit ctx: Context): Option[Term]
+
+### symbol
+def symbol(implicit ctx: Context): ValDefSymbol
+
+### tpt
+def tpt(implicit ctx: Context): TypeTree
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/While$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/While$.md
new file mode 100644
index 000000000000..fdd830a6794d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/While$.md
@@ -0,0 +1,16 @@
+scala.tasty.reflect.TreeOps
+# object While
+
+final object While extends Serializable
+## Concrete Value Members:
+### apply
+def apply(cond: Term, body: Term)(implicit ctx: Context): While
+Creates a while loop `while () ` and returns (, )
+
+### copy
+def copy(original: Tree)(cond: Term, body: Term)(implicit ctx: Context): While
+
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Option[(Term, Term)]
+Extractor for while loops. Matches `while () ` and returns (, )
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/WhileAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/WhileAPI.md
new file mode 100644
index 000000000000..284fb318c011
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/WhileAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TreeOps
+# class WhileAPI
+
+class WhileAPI
+## Constructors:
+WhileAPI(self: While)
+
+## Concrete Value Members:
+### body
+def body(implicit ctx: Context): Term
+
+### cond
+def cond(implicit ctx: Context): Term
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/WildcardTypeTree$.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/WildcardTypeTree$.md
new file mode 100644
index 000000000000..e6127fea0174
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/WildcardTypeTree$.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# object WildcardTypeTree
+
+final object WildcardTypeTree extends Serializable
+TypeBoundsTree containing wildcard type bounds
+
+## Concrete Value Members:
+### unapply
+def unapply(tree: Tree)(implicit ctx: Context): Boolean
+Matches a TypeBoundsTree containing wildcard type bounds
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeOps/WildcardTypeTreeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TreeOps/WildcardTypeTreeAPI.md
new file mode 100644
index 000000000000..5d07d5b03f80
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeOps/WildcardTypeTreeAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TreeOps
+# class WildcardTypeTreeAPI
+
+class WildcardTypeTreeAPI
+## Constructors:
+WildcardTypeTreeAPI(self: WildcardTypeTree)
+
+## Concrete Value Members:
+### tpe
+def tpe(implicit ctx: Context): TypeOrBounds
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeUtils.md b/tastydoc/documentation/scala/tasty/reflect/TreeUtils.md
new file mode 100644
index 000000000000..7fa7fb17499d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeUtils.md
@@ -0,0 +1,13 @@
+scala.tasty.reflect
+# trait TreeUtils
+
+trait TreeUtils extends Core with PatternOps with SymbolOps with TreeOps
+Tasty reflect case definition
+
+## Abstract Type Members:
+### TreeAccumulator
+abstract class TreeAccumulator
+### TreeMap
+abstract class TreeMap
+### TreeTraverser
+abstract class TreeTraverser
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeUtils/TreeAccumulator.md b/tastydoc/documentation/scala/tasty/reflect/TreeUtils/TreeAccumulator.md
new file mode 100644
index 000000000000..f8f71a4ebc5c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeUtils/TreeAccumulator.md
@@ -0,0 +1,23 @@
+scala.tasty.reflect.TreeUtils
+# class TreeAccumulator
+
+abstract class TreeAccumulator[X]
+## Concrete Value Members:
+### foldOverPattern
+def foldOverPattern(x: X, tree: Pattern)(implicit ctx: Context): X
+
+### foldOverTree
+def foldOverTree(x: X, tree: Tree)(implicit ctx: Context): X
+
+### foldPattern
+def foldPattern(x: X, tree: Pattern)(implicit ctx: Context): X
+
+### foldPatterns
+def foldPatterns(x: X, trees: Iterable[Pattern])(implicit ctx: Context): X
+
+### foldTree
+def foldTree(x: X, tree: Tree)(implicit ctx: Context): X
+
+### foldTrees
+def foldTrees(x: X, trees: Iterable[Tree])(implicit ctx: Context): X
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeUtils/TreeMap.md b/tastydoc/documentation/scala/tasty/reflect/TreeUtils/TreeMap.md
new file mode 100644
index 000000000000..b2b5142e4a1b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeUtils/TreeMap.md
@@ -0,0 +1,50 @@
+scala.tasty.reflect.TreeUtils
+# class TreeMap
+
+abstract class TreeMap
+## Concrete Value Members:
+### transformCaseDef
+def transformCaseDef(tree: CaseDef)(implicit ctx: Context): CaseDef
+
+### transformCaseDefs
+def transformCaseDefs(trees: List[CaseDef])(implicit ctx: Context): List[CaseDef]
+
+### transformPattern
+def transformPattern(pattern: Pattern)(implicit ctx: Context): Pattern
+
+### transformPatterns
+def transformPatterns(trees: List[Pattern])(implicit ctx: Context): List[Pattern]
+
+### transformStatement
+def transformStatement(tree: Statement)(implicit ctx: Context): Statement
+
+### transformStats
+def transformStats(trees: List[Statement])(implicit ctx: Context): List[Statement]
+
+### transformSubTrees
+def transformSubTrees[Tr <: TreeUtils.this.Tree](trees: List[Tr])(implicit ctx: Context): List[Tr]
+
+### transformTerm
+def transformTerm(tree: Term)(implicit ctx: Context): Term
+
+### transformTerms
+def transformTerms(trees: List[Term])(implicit ctx: Context): List[Term]
+
+### transformTree
+def transformTree(tree: Tree)(implicit ctx: Context): Tree
+
+### transformTrees
+def transformTrees(trees: List[Tree])(implicit ctx: Context): List[Tree]
+
+### transformTypeCaseDef
+def transformTypeCaseDef(tree: TypeCaseDef)(implicit ctx: Context): TypeCaseDef
+
+### transformTypeCaseDefs
+def transformTypeCaseDefs(trees: List[TypeCaseDef])(implicit ctx: Context): List[TypeCaseDef]
+
+### transformTypeTree
+def transformTypeTree(tree: TypeTree)(implicit ctx: Context): TypeTree
+
+### transformTypeTrees
+def transformTypeTrees(trees: List[TypeTree])(implicit ctx: Context): List[TypeTree]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TreeUtils/TreeTraverser.md b/tastydoc/documentation/scala/tasty/reflect/TreeUtils/TreeTraverser.md
new file mode 100644
index 000000000000..d872be998d62
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TreeUtils/TreeTraverser.md
@@ -0,0 +1,35 @@
+scala.tasty.reflect.TreeUtils
+# class TreeTraverser
+
+abstract class TreeTraverser extends TreeAccumulator[Unit]
+## Concrete Value Members:
+### foldOverPattern
+def foldOverPattern(x: X, tree: Pattern)(implicit ctx: Context): X
+
+### foldOverTree
+def foldOverTree(x: X, tree: Tree)(implicit ctx: Context): X
+
+### foldPattern
+def foldPattern(x: Unit, tree: Pattern)(implicit ctx: Context): Unit
+
+### foldPatterns
+def foldPatterns(x: X, trees: Iterable[Pattern])(implicit ctx: Context): X
+
+### foldTree
+def foldTree(x: Unit, tree: Tree)(implicit ctx: Context): Unit
+
+### foldTrees
+def foldTrees(x: X, trees: Iterable[Tree])(implicit ctx: Context): X
+
+### traversePattern
+def traversePattern(tree: Pattern)(implicit ctx: Context): Unit
+
+### traversePatternChildren
+protected def traversePatternChildren(tree: Pattern)(implicit ctx: Context): Unit
+
+### traverseTree
+def traverseTree(tree: Tree)(implicit ctx: Context): Unit
+
+### traverseTreeChildren
+protected def traverseTreeChildren(tree: Tree)(implicit ctx: Context): Unit
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps.md
new file mode 100644
index 000000000000..b41faa7a3aca
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps.md
@@ -0,0 +1,61 @@
+scala.tasty.reflect
+# trait TypeOrBoundsOps
+
+trait TypeOrBoundsOps extends Core
+## Concrete Type Members:
+### IsType
+final object IsType
+### IsTypeBounds
+final object IsTypeBounds
+### NoPrefix
+final object NoPrefix
+### Type
+final object Type
+### TypeBounds
+final object TypeBounds
+### TypeAPI
+class TypeAPI
+### TypeBoundsAPI
+class TypeBoundsAPI
+### Type_AndTypeAPI
+class Type_AndTypeAPI
+### Type_AnnotatedTypeAPI
+class Type_AnnotatedTypeAPI
+### Type_AppliedTypeAPI
+class Type_AppliedTypeAPI
+### Type_ByNameTypeAPI
+class Type_ByNameTypeAPI
+### Type_ConstantTypeAPI
+class Type_ConstantTypeAPI
+### Type_MatchTypeAPI
+class Type_MatchTypeAPI
+### Type_MethodTypeAPI
+class Type_MethodTypeAPI
+### Type_OrTypeAPI
+class Type_OrTypeAPI
+### Type_ParamRefAPI
+class Type_ParamRefAPI
+### Type_PolyTypeAPI
+class Type_PolyTypeAPI
+### Type_RecursiveThisAPI
+class Type_RecursiveThisAPI
+### Type_RecursiveTypeAPI
+class Type_RecursiveTypeAPI
+### Type_RefinementAPI
+class Type_RefinementAPI
+### Type_SuperTypeAPI
+class Type_SuperTypeAPI
+### Type_SymRefAPI
+class Type_SymRefAPI
+### Type_TermRefAPI
+class Type_TermRefAPI
+### Type_ThisTypeAPI
+class Type_ThisTypeAPI
+### Type_TypeLambdaAPI
+class Type_TypeLambdaAPI
+### Type_TypeRefAPI
+class Type_TypeRefAPI
+## Concrete Value Members:
+### typeOf
+def typeOf[T](implicit evidence$2: Type[T]): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/IsType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/IsType$.md
new file mode 100644
index 000000000000..4f0a37d430ff
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/IsType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# object IsType
+
+final object IsType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[Type]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/IsTypeBounds$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/IsTypeBounds$.md
new file mode 100644
index 000000000000..9b11b04cd987
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/IsTypeBounds$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# object IsTypeBounds
+
+final object IsTypeBounds extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[TypeBounds]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/NoPrefix$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/NoPrefix$.md
new file mode 100644
index 000000000000..7795722bc0ab
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/NoPrefix$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# object NoPrefix
+
+final object NoPrefix extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Boolean
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$.md
new file mode 100644
index 000000000000..b1fa66a557c9
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$.md
@@ -0,0 +1,81 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# object Type
+
+final object Type extends Serializable
+## Concrete Type Members:
+### AndType
+final object AndType
+### AnnotatedType
+final object AnnotatedType
+### AppliedType
+final object AppliedType
+### ByNameType
+final object ByNameType
+### ConstantType
+final object ConstantType
+### IsAndType
+final object IsAndType
+### IsAnnotatedType
+final object IsAnnotatedType
+### IsAppliedType
+final object IsAppliedType
+### IsByNameType
+final object IsByNameType
+### IsConstantType
+final object IsConstantType
+### IsMatchType
+final object IsMatchType
+### IsMethodType
+final object IsMethodType
+### IsOrType
+final object IsOrType
+### IsParamRef
+final object IsParamRef
+### IsPolyType
+final object IsPolyType
+### IsRecursiveThis
+final object IsRecursiveThis
+### IsRecursiveType
+final object IsRecursiveType
+### IsRefinement
+final object IsRefinement
+### IsSuperType
+final object IsSuperType
+### IsSymRef
+final object IsSymRef
+### IsTermRef
+final object IsTermRef
+### IsThisType
+final object IsThisType
+### IsTypeLambda
+final object IsTypeLambda
+### IsTypeRef
+final object IsTypeRef
+### MatchType
+final object MatchType
+### MethodType
+final object MethodType
+### OrType
+final object OrType
+### ParamRef
+final object ParamRef
+### PolyType
+final object PolyType
+### RecursiveThis
+final object RecursiveThis
+### RecursiveType
+final object RecursiveType
+### Refinement
+final object Refinement
+### SuperType
+final object SuperType
+### SymRef
+final object SymRef
+### TermRef
+final object TermRef
+### ThisType
+final object ThisType
+### TypeLambda
+final object TypeLambda
+### TypeRef
+final object TypeRef
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/AndType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/AndType$.md
new file mode 100644
index 000000000000..eda83db95e1a
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/AndType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object AndType
+
+final object AndType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/AnnotatedType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/AnnotatedType$.md
new file mode 100644
index 000000000000..fc4f5e4ea392
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/AnnotatedType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object AnnotatedType
+
+final object AnnotatedType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(Type, Term)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/AppliedType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/AppliedType$.md
new file mode 100644
index 000000000000..5f359f772067
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/AppliedType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object AppliedType
+
+final object AppliedType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(Type, List[TypeOrBounds])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ByNameType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ByNameType$.md
new file mode 100644
index 000000000000..8e0a152c5858
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ByNameType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object ByNameType
+
+final object ByNameType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[Type]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ConstantType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ConstantType$.md
new file mode 100644
index 000000000000..b66866e8ee86
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ConstantType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object ConstantType
+
+final object ConstantType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[Constant]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsAndType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsAndType$.md
new file mode 100644
index 000000000000..b3534ee324c6
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsAndType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsAndType
+
+final object IsAndType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[AndType]
+Matches any AndType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsAnnotatedType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsAnnotatedType$.md
new file mode 100644
index 000000000000..7b8d77ebec16
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsAnnotatedType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsAnnotatedType
+
+final object IsAnnotatedType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[AnnotatedType]
+Matches any AnnotatedType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsAppliedType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsAppliedType$.md
new file mode 100644
index 000000000000..9e793f78599f
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsAppliedType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsAppliedType
+
+final object IsAppliedType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[AppliedType]
+Matches any AppliedType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsByNameType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsByNameType$.md
new file mode 100644
index 000000000000..155619da4122
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsByNameType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsByNameType
+
+final object IsByNameType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[ByNameType]
+Matches any ByNameType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsConstantType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsConstantType$.md
new file mode 100644
index 000000000000..7cd71153ebab
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsConstantType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsConstantType
+
+final object IsConstantType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[ConstantType]
+Matches any ConstantType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsMatchType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsMatchType$.md
new file mode 100644
index 000000000000..cc4bc4412da7
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsMatchType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsMatchType
+
+final object IsMatchType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[MatchType]
+Matches any MatchType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsMethodType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsMethodType$.md
new file mode 100644
index 000000000000..b1009e7ada28
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsMethodType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsMethodType
+
+final object IsMethodType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[MethodType]
+Matches any MethodType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsOrType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsOrType$.md
new file mode 100644
index 000000000000..f8c6d0417918
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsOrType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsOrType
+
+final object IsOrType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[OrType]
+Matches any OrType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsParamRef$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsParamRef$.md
new file mode 100644
index 000000000000..084305ebc569
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsParamRef$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsParamRef
+
+final object IsParamRef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[ParamRef]
+Matches any ParamRef and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsPolyType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsPolyType$.md
new file mode 100644
index 000000000000..e27310a2c231
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsPolyType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsPolyType
+
+final object IsPolyType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[PolyType]
+Matches any PolyType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsRecursiveThis$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsRecursiveThis$.md
new file mode 100644
index 000000000000..afbc2e6656a2
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsRecursiveThis$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsRecursiveThis
+
+final object IsRecursiveThis extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[RecursiveThis]
+Matches any RecursiveThis and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsRecursiveType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsRecursiveType$.md
new file mode 100644
index 000000000000..e7aa19b4fea9
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsRecursiveType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsRecursiveType
+
+final object IsRecursiveType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[RecursiveType]
+Matches any RecursiveType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsRefinement$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsRefinement$.md
new file mode 100644
index 000000000000..2202177704d2
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsRefinement$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsRefinement
+
+final object IsRefinement extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[Refinement]
+Matches any Refinement and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsSuperType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsSuperType$.md
new file mode 100644
index 000000000000..db1b54a7b0ca
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsSuperType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsSuperType
+
+final object IsSuperType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[SuperType]
+Matches any SuperType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsSymRef$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsSymRef$.md
new file mode 100644
index 000000000000..990408a1ad57
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsSymRef$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsSymRef
+
+final object IsSymRef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[SymRef]
+Matches any SymRef and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsTermRef$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsTermRef$.md
new file mode 100644
index 000000000000..40765d87ef85
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsTermRef$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsTermRef
+
+final object IsTermRef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[TermRef]
+Matches any TermRef and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsThisType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsThisType$.md
new file mode 100644
index 000000000000..6280232193d2
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsThisType$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsThisType
+
+final object IsThisType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[ThisType]
+Matches any ThisType and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsTypeLambda$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsTypeLambda$.md
new file mode 100644
index 000000000000..d6f80100425e
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsTypeLambda$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsTypeLambda
+
+final object IsTypeLambda extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[TypeLambda]
+Matches any TypeLambda and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsTypeRef$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsTypeRef$.md
new file mode 100644
index 000000000000..ee3ab9229789
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/IsTypeRef$.md
@@ -0,0 +1,9 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object IsTypeRef
+
+final object IsTypeRef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(tpe: TypeOrBounds)(implicit ctx: Context): Option[TypeRef]
+Matches any TypeRef and returns it
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/MatchType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/MatchType$.md
new file mode 100644
index 000000000000..813afac9679c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/MatchType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object MatchType
+
+final object MatchType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type, List[Type])]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/MethodType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/MethodType$.md
new file mode 100644
index 000000000000..5143a952ff4d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/MethodType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object MethodType
+
+final object MethodType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(List[String], List[Type], Type)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/OrType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/OrType$.md
new file mode 100644
index 000000000000..8d48dd033db4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/OrType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object OrType
+
+final object OrType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ParamRef$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ParamRef$.md
new file mode 100644
index 000000000000..1ebc9078ad7a
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ParamRef$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object ParamRef
+
+final object ParamRef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(LambdaType[TypeOrBounds], Int)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/PolyType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/PolyType$.md
new file mode 100644
index 000000000000..9bd4a601b721
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/PolyType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object PolyType
+
+final object PolyType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(List[String], List[TypeBounds], Type)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/RecursiveThis$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/RecursiveThis$.md
new file mode 100644
index 000000000000..5d9676e08dde
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/RecursiveThis$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object RecursiveThis
+
+final object RecursiveThis extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[RecursiveType]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/RecursiveType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/RecursiveType$.md
new file mode 100644
index 000000000000..2d117ecbf560
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/RecursiveType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object RecursiveType
+
+final object RecursiveType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[Type]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/Refinement$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/Refinement$.md
new file mode 100644
index 000000000000..e68547534b1b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/Refinement$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object Refinement
+
+final object Refinement extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(Type, String, TypeOrBounds)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/SuperType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/SuperType$.md
new file mode 100644
index 000000000000..6763e4edcfc4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/SuperType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object SuperType
+
+final object SuperType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/SymRef$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/SymRef$.md
new file mode 100644
index 000000000000..6938ceaadc8d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/SymRef$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object SymRef
+
+final object SymRef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(Symbol, TypeOrBounds)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/TermRef$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/TermRef$.md
new file mode 100644
index 000000000000..35cf446e783a
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/TermRef$.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object TermRef
+
+final object TermRef extends Serializable
+## Concrete Value Members:
+### apply
+def apply(qual: TypeOrBounds, name: String)(implicit ctx: Context): TermRef
+
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(String, TypeOrBounds)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ThisType$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ThisType$.md
new file mode 100644
index 000000000000..7b6a2ac5f2d3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/ThisType$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object ThisType
+
+final object ThisType extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[Type]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/TypeLambda$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/TypeLambda$.md
new file mode 100644
index 000000000000..a6afa0c2a99d
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/TypeLambda$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object TypeLambda
+
+final object TypeLambda extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(List[String], List[TypeBounds], Type)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/TypeRef$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/TypeRef$.md
new file mode 100644
index 000000000000..86209a895254
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type$/TypeRef$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps.Type$
+# object TypeRef
+
+final object TypeRef extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(String, TypeOrBounds)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/TypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/TypeAPI.md
new file mode 100644
index 000000000000..d01ab9de68f3
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/TypeAPI.md
@@ -0,0 +1,68 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class TypeAPI
+
+class TypeAPI
+## Constructors:
+TypeAPI(self: Type)
+
+## Concrete Value Members:
+### <:<
+def <:<(that: Type)(implicit ctx: Context): Boolean
+
+### =:=
+def =:=(that: Type)(implicit ctx: Context): Boolean
+
+### classSymbol
+def classSymbol(implicit ctx: Context): Option[ClassDefSymbol]
+
+### dealias
+def dealias(implicit ctx: Context): Type
+Follow aliases and dereferences LazyRefs, annotated types and instantiated
+TypeVars until type is no longer alias type, annotated type, LazyRef,
+or instantiated type variable.
+
+### derivesFrom
+def derivesFrom(cls: ClassDefSymbol)(implicit ctx: Context): Boolean
+Is this type an instance of a non-bottom subclass of the given class `cls`?
+
+### isDependentFunctionType
+def isDependentFunctionType(implicit ctx: Context): Boolean
+Is this type a dependent function type?
+
+***see*** `isFunctionType`
+
+### isErasedFunctionType
+def isErasedFunctionType(implicit ctx: Context): Boolean
+Is this type an erased function type?
+
+***see*** `isFunctionType`
+
+### isFunctionType
+def isFunctionType(implicit ctx: Context): Boolean
+Is this type a function type?
+
+***return*** true if the dealised type of `self` without refinement is `FunctionN[T1, T2, ..., Tn]`
+
+***Note*** The function
+* returns true for `given Int => Int` and `erased Int => Int`
+* returns false for `List[Int]`, despite that `List[Int] <:< Int => Int`.
+
+
+### isImplicitFunctionType
+def isImplicitFunctionType(implicit ctx: Context): Boolean
+Is this type an implicit function type?
+
+***see*** `isFunctionType`
+
+### isSingleton
+def isSingleton(implicit ctx: Context): Boolean
+
+### memberType
+def memberType(member: Symbol)(implicit ctx: Context): Type
+
+### typeSymbol
+def typeSymbol(implicit ctx: Context): Symbol
+
+### widen
+def widen(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/TypeBounds$.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/TypeBounds$.md
new file mode 100644
index 000000000000..9e682c4e4973
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/TypeBounds$.md
@@ -0,0 +1,8 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# object TypeBounds
+
+final object TypeBounds extends Serializable
+## Concrete Value Members:
+### unapply
+def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type)]
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/TypeBoundsAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/TypeBoundsAPI.md
new file mode 100644
index 000000000000..8775fabc1cd4
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/TypeBoundsAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class TypeBoundsAPI
+
+class TypeBoundsAPI
+## Constructors:
+TypeBoundsAPI(self: TypeBounds)
+
+## Concrete Value Members:
+### hi
+def hi(implicit ctx: Context): Type
+
+### low
+def low(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_AndTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_AndTypeAPI.md
new file mode 100644
index 000000000000..7933633ce012
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_AndTypeAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_AndTypeAPI
+
+class Type_AndTypeAPI
+## Constructors:
+Type_AndTypeAPI(self: AndType)
+
+## Concrete Value Members:
+### left
+def left(implicit ctx: Context): Type
+
+### right
+def right(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_AnnotatedTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_AnnotatedTypeAPI.md
new file mode 100644
index 000000000000..52e8196cb10c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_AnnotatedTypeAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_AnnotatedTypeAPI
+
+class Type_AnnotatedTypeAPI
+## Constructors:
+Type_AnnotatedTypeAPI(self: AnnotatedType)
+
+## Concrete Value Members:
+### annot
+def annot(implicit ctx: Context): Term
+
+### underlying
+def underlying(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_AppliedTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_AppliedTypeAPI.md
new file mode 100644
index 000000000000..dd8f2248f8f1
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_AppliedTypeAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_AppliedTypeAPI
+
+class Type_AppliedTypeAPI
+## Constructors:
+Type_AppliedTypeAPI(self: AppliedType)
+
+## Concrete Value Members:
+### args
+def args(implicit ctx: Context): List[TypeOrBounds]
+
+### tycon
+def tycon(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ByNameTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ByNameTypeAPI.md
new file mode 100644
index 000000000000..8d24f822f7ed
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ByNameTypeAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_ByNameTypeAPI
+
+class Type_ByNameTypeAPI
+## Constructors:
+Type_ByNameTypeAPI(self: ByNameType)
+
+## Concrete Value Members:
+### underlying
+def underlying(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ConstantTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ConstantTypeAPI.md
new file mode 100644
index 000000000000..24292af8b345
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ConstantTypeAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_ConstantTypeAPI
+
+class Type_ConstantTypeAPI
+## Constructors:
+Type_ConstantTypeAPI(self: ConstantType)
+
+## Concrete Value Members:
+### constant
+def constant(implicit ctx: Context): Constant
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_MatchTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_MatchTypeAPI.md
new file mode 100644
index 000000000000..79bf50c9922c
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_MatchTypeAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_MatchTypeAPI
+
+class Type_MatchTypeAPI
+## Constructors:
+Type_MatchTypeAPI(self: MatchType)
+
+## Concrete Value Members:
+### bound
+def bound(implicit ctx: Context): Type
+
+### cases
+def cases(implicit ctx: Context): List[Type]
+
+### scrutinee
+def scrutinee(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_MethodTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_MethodTypeAPI.md
new file mode 100644
index 000000000000..cce631fa224b
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_MethodTypeAPI.md
@@ -0,0 +1,23 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_MethodTypeAPI
+
+class Type_MethodTypeAPI
+## Constructors:
+Type_MethodTypeAPI(self: MethodType)
+
+## Concrete Value Members:
+### isErased
+def isErased: Boolean
+
+### isImplicit
+def isImplicit: Boolean
+
+### paramNames
+def paramNames(implicit ctx: Context): List[String]
+
+### paramTypes
+def paramTypes(implicit ctx: Context): List[Type]
+
+### resType
+def resType(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_OrTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_OrTypeAPI.md
new file mode 100644
index 000000000000..2e14402e4db1
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_OrTypeAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_OrTypeAPI
+
+class Type_OrTypeAPI
+## Constructors:
+Type_OrTypeAPI(self: OrType)
+
+## Concrete Value Members:
+### left
+def left(implicit ctx: Context): Type
+
+### right
+def right(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ParamRefAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ParamRefAPI.md
new file mode 100644
index 000000000000..b36c88838bc2
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ParamRefAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_ParamRefAPI
+
+class Type_ParamRefAPI
+## Constructors:
+Type_ParamRefAPI(self: ParamRef)
+
+## Concrete Value Members:
+### binder
+def binder(implicit ctx: Context): LambdaType[TypeOrBounds]
+
+### paramNum
+def paramNum(implicit ctx: Context): Int
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_PolyTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_PolyTypeAPI.md
new file mode 100644
index 000000000000..c42b8df11d7a
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_PolyTypeAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_PolyTypeAPI
+
+class Type_PolyTypeAPI
+## Constructors:
+Type_PolyTypeAPI(self: PolyType)
+
+## Concrete Value Members:
+### paramBounds
+def paramBounds(implicit ctx: Context): List[TypeBounds]
+
+### paramNames
+def paramNames(implicit ctx: Context): List[String]
+
+### resType
+def resType(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_RecursiveThisAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_RecursiveThisAPI.md
new file mode 100644
index 000000000000..fe376a6e1d61
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_RecursiveThisAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_RecursiveThisAPI
+
+class Type_RecursiveThisAPI
+## Constructors:
+Type_RecursiveThisAPI(self: RecursiveThis)
+
+## Concrete Value Members:
+### binder
+def binder(implicit ctx: Context): RecursiveType
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_RecursiveTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_RecursiveTypeAPI.md
new file mode 100644
index 000000000000..d3fe54973d5f
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_RecursiveTypeAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_RecursiveTypeAPI
+
+class Type_RecursiveTypeAPI
+## Constructors:
+Type_RecursiveTypeAPI(self: RecursiveType)
+
+## Concrete Value Members:
+### underlying
+def underlying(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_RefinementAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_RefinementAPI.md
new file mode 100644
index 000000000000..ed9376528d18
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_RefinementAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_RefinementAPI
+
+class Type_RefinementAPI
+## Constructors:
+Type_RefinementAPI(self: Refinement)
+
+## Concrete Value Members:
+### info
+def info(implicit ctx: Context): TypeOrBounds
+
+### name
+def name(implicit ctx: Context): String
+
+### parent
+def parent(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_SuperTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_SuperTypeAPI.md
new file mode 100644
index 000000000000..10594d0be949
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_SuperTypeAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_SuperTypeAPI
+
+class Type_SuperTypeAPI
+## Constructors:
+Type_SuperTypeAPI(self: SuperType)
+
+## Concrete Value Members:
+### supertpe
+def supertpe(implicit ctx: Context): Type
+
+### thistpe
+def thistpe(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_SymRefAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_SymRefAPI.md
new file mode 100644
index 000000000000..b4aee5e3e397
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_SymRefAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_SymRefAPI
+
+class Type_SymRefAPI
+## Constructors:
+Type_SymRefAPI(self: SymRef)
+
+## Concrete Value Members:
+### qualifier
+def qualifier(implicit ctx: Context): TypeOrBounds
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_TermRefAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_TermRefAPI.md
new file mode 100644
index 000000000000..0879731ec6a0
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_TermRefAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_TermRefAPI
+
+class Type_TermRefAPI
+## Constructors:
+Type_TermRefAPI(self: TermRef)
+
+## Concrete Value Members:
+### name
+def name(implicit ctx: Context): String
+
+### qualifier
+def qualifier(implicit ctx: Context): TypeOrBounds
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ThisTypeAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ThisTypeAPI.md
new file mode 100644
index 000000000000..2f32333cdf74
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_ThisTypeAPI.md
@@ -0,0 +1,11 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_ThisTypeAPI
+
+class Type_ThisTypeAPI
+## Constructors:
+Type_ThisTypeAPI(self: ThisType)
+
+## Concrete Value Members:
+### tref
+def tref(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_TypeLambdaAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_TypeLambdaAPI.md
new file mode 100644
index 000000000000..63ab28abf0f9
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_TypeLambdaAPI.md
@@ -0,0 +1,17 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_TypeLambdaAPI
+
+class Type_TypeLambdaAPI
+## Constructors:
+Type_TypeLambdaAPI(self: TypeLambda)
+
+## Concrete Value Members:
+### paramBounds
+def paramBounds(implicit ctx: Context): List[TypeBounds]
+
+### paramNames
+def paramNames(implicit ctx: Context): List[String]
+
+### resType
+def resType(implicit ctx: Context): Type
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_TypeRefAPI.md b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_TypeRefAPI.md
new file mode 100644
index 000000000000..2f92833a7d04
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/TypeOrBoundsOps/Type_TypeRefAPI.md
@@ -0,0 +1,14 @@
+scala.tasty.reflect.TypeOrBoundsOps
+# class Type_TypeRefAPI
+
+class Type_TypeRefAPI
+## Constructors:
+Type_TypeRefAPI(self: TypeRef)
+
+## Concrete Value Members:
+### name
+def name(implicit ctx: Context): String
+
+### qualifier
+def qualifier(implicit ctx: Context): TypeOrBounds
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/reflect.md b/tastydoc/documentation/scala/tasty/reflect/reflect.md
new file mode 100644
index 000000000000..7a0ba95a85cc
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/reflect.md
@@ -0,0 +1,237 @@
+# Package reflect
+## Members:
+trait QuotedOps
+Extension methods on scala.quoted.{Expr|Type} to convert to scala.tasty.Tasty objects
+
+trait ImportSelectorOps
+trait TreeUtils
+Tasty reflect case definition
+
+trait Kernel
+Tasty reflect abstract types
+```none```
++- Tree -+- PackageClause
+ +- Import
+ +- Statement -+- Definition --+- PackageDef
+ | | +- ClassDef
+ | | +- TypeDef
+ | | +- DefDef
+ | | +- ValDef
+ | |
+ | +- Term --------+- Ref -+- Ident
+ | | +- Select
+ | |
+ | +- Literal
+ | +- This
+ | +- New
+ | +- NamedArg
+ | +- Apply
+ | +- TypeApply
+ | +- Super
+ | +- Typed
+ | +- Assign
+ | +- Block
+ | +- Lambda
+ | +- If
+ | +- Match
+ | +- ImpliedMatch
+ | +- Try
+ | +- Return
+ | +- Repeated
+ | +- Inlined
+ | +- SelectOuter
+ | +- While
+ |
+ |
+ +- TypeTree ----+- Inferred
+ | +- TypeIdent
+ | +- TypeSelect
+ | +- Projection
+ | +- Singleton
+ | +- Refined
+ | +- Applied
+ | +- Annotated
+ | +- MatchTypeTree
+ | +- ByName
+ | +- LambdaTypeTree
+ | +- TypeBind
+ | +- TypeBlock
+ |
+ +- TypeBoundsTree
+ +- WildcardTypeTree
+ +- CaseDef
+ +- TypeCaseDef
++- Pattern --+- Value
+ +- Bind
+ +- Unapply
+ +- Alternatives
+ +- TypeTest
+ +- WildcardPattern
+ +- NoPrefix
++- TypeOrBounds -+- TypeBounds
+ |
+ +- Type -------+- ConstantType
+ +- SymRef
+ +- TermRef
+ +- TypeRef
+ +- SuperType
+ +- Refinement
+ +- AppliedType
+ +- AnnotatedType
+ +- AndType
+ +- OrType
+ +- MatchType
+ +- ByNameType
+ +- ParamRef
+ +- ThisType
+ +- RecursiveThis
+ +- RecursiveType
+ +- LambdaType[ParamInfo <: TypeOrBounds] -+- MethodType
+ +- PolyType
+ +- TypeLambda
++- ImportSelector -+- SimpleSelector
+ +- RenameSelector
+ +- OmitSelector
++- Id
++- Signature
++- Position
++- Comment
++- Constant
++- Symbol --+- PackageDefSymbol
+ |
+ +- TypeSymbol -+- ClassDefSymbol
+ | +- TypeDefSymbol
+ | +- TypeBindSymbol
+ |
+ +- TermSymbol -+- DefDefSymbol
+ | +- ValDefSymbol
+ | +- BindSymbol
+ |
+ +- NoSymbol
++- Flags
+```
+```
+
+trait ContextOps
+trait ReportingOps
+trait ConstantOps
+trait Core
+Tasty reflect abstract types
+```none```
++- Tree -+- PackageClause
+ +- Import
+ +- Statement -+- Definition --+- PackageDef
+ | | +- ClassDef
+ | | +- TypeDef
+ | | +- DefDef
+ | | +- ValDef
+ | |
+ | +- Term --------+- Ref -+- Ident
+ | | +- Select
+ | |
+ | +- Literal
+ | +- This
+ | +- New
+ | +- NamedArg
+ | +- Apply
+ | +- TypeApply
+ | +- Super
+ | +- Typed
+ | +- Assign
+ | +- Block
+ | +- Lambda
+ | +- If
+ | +- Match
+ | +- ImpliedMatch
+ | +- Try
+ | +- Return
+ | +- Repeated
+ | +- Inlined
+ | +- SelectOuter
+ | +- While
+ |
+ |
+ +- TypeTree ----+- Inferred
+ | +- TypeIdent
+ | +- TypeSelect
+ | +- Projection
+ | +- Singleton
+ | +- Refined
+ | +- Applied
+ | +- Annotated
+ | +- MatchTypeTree
+ | +- ByName
+ | +- LambdaTypeTree
+ | +- TypeBind
+ | +- TypeBlock
+ |
+ +- TypeBoundsTree
+ +- WildcardTypeTree
+ +- CaseDef
+ +- TypeCaseDef
++- Pattern --+- Value
+ +- Bind
+ +- Unapply
+ +- Alternatives
+ +- TypeTest
+ +- WildcardPattern
+ +- NoPrefix
++- TypeOrBounds -+- TypeBounds
+ |
+ +- Type -------+- ConstantType
+ +- SymRef
+ +- TermRef
+ +- TypeRef
+ +- SuperType
+ +- Refinement
+ +- AppliedType
+ +- AnnotatedType
+ +- AndType
+ +- OrType
+ +- MatchType
+ +- ByNameType
+ +- ParamRef
+ +- ThisType
+ +- RecursiveThis
+ +- RecursiveType
+ +- LambdaType[ParamInfo <: TypeOrBounds] -+- MethodType
+ +- PolyType
+ +- TypeLambda
++- ImportSelector -+- SimpleSelector
+ +- RenameSelector
+ +- OmitSelector
++- Id
++- Signature
++- Position
++- Comment
++- Constant
++- Symbol --+- PackageDefSymbol
+ |
+ +- TypeSymbol -+- ClassDefSymbol
+ | +- TypeDefSymbol
+ | +- TypeBindSymbol
+ |
+ +- TermSymbol -+- DefDefSymbol
+ | +- ValDefSymbol
+ | +- BindSymbol
+ |
+ +- NoSymbol
++- Flags
+```
+```
+
+trait SignatureOps
+class ExprCastError
+trait PositionOps
+trait IdOps
+trait Printers
+trait PatternOps
+trait RootPosition
+trait FlagsOps
+trait TypeOrBoundsOps
+trait TreeOps
+trait StandardDefinitions
+trait SymbolOps
+Tasty reflect symbol
+
+trait CommentOps
diff --git a/tastydoc/documentation/scala/tasty/reflect/utils/TreeUtils.md b/tastydoc/documentation/scala/tasty/reflect/utils/TreeUtils.md
new file mode 100644
index 000000000000..d1f96ee2ffc7
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/utils/TreeUtils.md
@@ -0,0 +1,13 @@
+scala.tasty.reflect.utils
+# trait TreeUtils
+
+trait TreeUtils
+## Concrete Value Members:
+### let
+def let(rhs: Term)(body: (Ident) => Term): Term
+Bind the `rhs` to a `val` and use it in `body`
+
+### lets
+def lets(terms: List[Term])(body: (List[Term]) => Term): Term
+Bind the given `terms` to names and use them in the `body`
+
diff --git a/tastydoc/documentation/scala/tasty/reflect/utils/utils.md b/tastydoc/documentation/scala/tasty/reflect/utils/utils.md
new file mode 100644
index 000000000000..b7495a43a615
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/reflect/utils/utils.md
@@ -0,0 +1,3 @@
+# Package utils
+## Members:
+trait TreeUtils
diff --git a/tastydoc/documentation/scala/tasty/tasty.md b/tastydoc/documentation/scala/tasty/tasty.md
new file mode 100644
index 000000000000..ef0e518e91c1
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/tasty.md
@@ -0,0 +1,7 @@
+# Package tasty
+## Members:
+final object Reflection
+final val Reflection: Reflection
+
+class Reflection
+package util
package reflect
package utils
\ No newline at end of file
diff --git a/tastydoc/documentation/scala/tasty/util/Chars$.md b/tastydoc/documentation/scala/tasty/util/Chars$.md
new file mode 100644
index 000000000000..8065810e1005
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/util/Chars$.md
@@ -0,0 +1,66 @@
+scala.tasty.util
+# object Chars
+
+final object Chars extends Serializable
+Contains constants and classifier methods for characters
+
+## Concrete Value Members:
+### char2uescape
+def char2uescape(c: Char): String
+Convert a character to a backslash-u escape
+
+### digit2int
+def digit2int(ch: Char, base: Int): Int
+Convert a character digit to an Int according to given base,
+-1 if no success
+
+### isIdentifierPart
+def isIdentifierPart(c: Char): Boolean
+Can character form part of an alphanumeric Scala identifier?
+
+### isIdentifierStart
+def isIdentifierStart(c: Char): Boolean
+Can character start an alphanumeric Scala identifier?
+
+### isLineBreakChar
+def isLineBreakChar(c: Char): Boolean
+Is character a line break?
+
+### isOperatorPart
+def isOperatorPart(c: Char): Boolean
+Can character form part of a Scala operator name?
+
+### isScalaLetter
+def isScalaLetter(ch: Char): Boolean
+
+### isSpecial
+def isSpecial(c: Char): Boolean
+Is character a math or other symbol in Unicode?
+
+### isValidJVMChar
+def isValidJVMChar(c: Char): Boolean
+
+### isValidJVMMethodChar
+def isValidJVMMethodChar(c: Char): Boolean
+
+### isVarPart
+def isVarPart(c: Char): Boolean
+Can character form part of a doc comment variable $xxx?
+
+### isWhitespace
+def isWhitespace(c: Char): Boolean
+Is character a whitespace character (but not a new line)?
+
+### CR
+final inline val CR:
+
+### FF
+final inline val FF:
+
+### LF
+final inline val LF:
+
+
+### SU
+final inline val SU:
+
diff --git a/tastydoc/documentation/scala/tasty/util/SyntaxHighlightUtils$.md b/tastydoc/documentation/scala/tasty/util/SyntaxHighlightUtils$.md
new file mode 100644
index 000000000000..1da9bfe043e0
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/util/SyntaxHighlightUtils$.md
@@ -0,0 +1,29 @@
+scala.tasty.util
+# object SyntaxHighlightUtils
+
+final object SyntaxHighlightUtils extends Serializable
+## Concrete Value Members:
+### highlightAnnotation
+def highlightAnnotation(str: String, withColor: Boolean): String
+
+### highlightKeyword
+def highlightKeyword(str: String, withColor: Boolean): String
+
+### highlightLiteral
+def highlightLiteral(str: String, withColor: Boolean): String
+
+### highlightOperator
+def highlightOperator(str: String, withColor: Boolean): String
+
+### highlightString
+def highlightString(str: String, withColor: Boolean): String
+
+### highlightTypeDef
+def highlightTypeDef(str: String, withColor: Boolean): String
+
+### highlightValDef
+def highlightValDef(str: String, withColor: Boolean): String
+
+### tripleQs
+val tripleQs: String
+
diff --git a/tastydoc/documentation/scala/tasty/util/util.md b/tastydoc/documentation/scala/tasty/util/util.md
new file mode 100644
index 000000000000..a8e7d9fc534a
--- /dev/null
+++ b/tastydoc/documentation/scala/tasty/util/util.md
@@ -0,0 +1,12 @@
+# Package util
+## Members:
+final object Chars
+Contains constants and classifier methods for characters
+
+final val Chars: Chars
+Contains constants and classifier methods for characters
+
+
+final object SyntaxHighlightUtils
+final val SyntaxHighlightUtils: SyntaxHighlightUtils
+
diff --git a/tastydoc/documentation/scala/testing/testing.md b/tastydoc/documentation/scala/testing/testing.md
new file mode 100644
index 000000000000..0d0130549331
--- /dev/null
+++ b/tastydoc/documentation/scala/testing/testing.md
@@ -0,0 +1,5 @@
+# Package testing
+## Members:
+final object typeChecks$package
+final val typeChecks$package: typeChecks$package
+
diff --git a/tastydoc/documentation/scala/testing/typeChecks$package$.md b/tastydoc/documentation/scala/testing/typeChecks$package$.md
new file mode 100644
index 000000000000..003ce1d9d69a
--- /dev/null
+++ b/tastydoc/documentation/scala/testing/typeChecks$package$.md
@@ -0,0 +1,11 @@
+scala.testing
+# object typeChecks$package
+
+final object typeChecks$package extends Serializable
+## Concrete Value Members:
+### typeChecks
+inline def typeChecks(code: String): Boolean
+
+### typeChecksImpl
+private[testing] def typeChecksImpl(code: String)(implicit reflect: Reflection): Expr[Boolean]
+
diff --git a/tastydoc/documentation/scala/util/control/NonLocalReturns$.md b/tastydoc/documentation/scala/util/control/NonLocalReturns$.md
new file mode 100644
index 000000000000..a673de63b1a3
--- /dev/null
+++ b/tastydoc/documentation/scala/util/control/NonLocalReturns$.md
@@ -0,0 +1,21 @@
+scala.util.control
+# object NonLocalReturns
+
+final object NonLocalReturns extends Serializable
+Library implementation of nonlocal return.
+Usage:
+ import scala.util.control.NonLocalReturns._
+ returning { ... throwReturn(x) ... }
+
+## Concrete Type Members:
+### ReturnThrowable
+class ReturnThrowable
+## Concrete Value Members:
+### returning
+def returning[T](op: ImplicitFunction1[ReturnThrowable[T], T]): T
+Enable nonlocal returns in `op`.
+
+### throwReturn
+def throwReturn[T](result: T)(returner: ReturnThrowable[T]): Nothing
+Performs a nonlocal return by throwing an exception.
+
diff --git a/tastydoc/documentation/scala/util/control/NonLocalReturns$/ReturnThrowable.md b/tastydoc/documentation/scala/util/control/NonLocalReturns$/ReturnThrowable.md
new file mode 100644
index 000000000000..643262decfe4
--- /dev/null
+++ b/tastydoc/documentation/scala/util/control/NonLocalReturns$/ReturnThrowable.md
@@ -0,0 +1,56 @@
+scala.util.control.NonLocalReturns$
+# class ReturnThrowable
+
+class ReturnThrowable[T] extends Throwable with ControlThrowable
+## Concrete Value Members:
+### addSuppressed
+final def addSuppressed(x$0: Throwable): Unit
+
+### fillInStackTrace
+override def fillInStackTrace(): Throwable
+
+### getCause
+def getCause(): Throwable
+
+### getLocalizedMessage
+def getLocalizedMessage(): String
+
+### getMessage
+def getMessage(): String
+
+### getStackTrace
+def getStackTrace(): Array[StackTraceElement]
+
+### getStackTraceDepth
+private[lang] def getStackTraceDepth(): Int
+
+### getStackTraceElement
+private[lang] def getStackTraceElement(x$0: Int): StackTraceElement
+
+### getSuppressed
+final def getSuppressed(): Array[Throwable]
+
+### initCause
+def initCause(x$0: Throwable): Throwable
+
+### printStackTrace
+def printStackTrace(x$0: PrintWriter): Unit
+
+### printStackTrace
+def printStackTrace(x$0: PrintStream): Unit
+
+### printStackTrace
+def printStackTrace(): Unit
+
+### result
+def result: T
+
+### setStackTrace
+def setStackTrace(x$0: Array[StackTraceElement]): Unit
+
+### throwReturn
+def throwReturn(result: T): Nothing
+
+### toString
+def toString(): String
+
diff --git a/tastydoc/documentation/scala/util/control/control.md b/tastydoc/documentation/scala/util/control/control.md
new file mode 100644
index 000000000000..34241347aadd
--- /dev/null
+++ b/tastydoc/documentation/scala/util/control/control.md
@@ -0,0 +1,15 @@
+# Package control
+## Members:
+final object NonLocalReturns
+Library implementation of nonlocal return.
+Usage:
+ import scala.util.control.NonLocalReturns._
+ returning { ... throwReturn(x) ... }
+
+final val NonLocalReturns: NonLocalReturns
+Library implementation of nonlocal return.
+Usage:
+ import scala.util.control.NonLocalReturns._
+ returning { ... throwReturn(x) ... }
+
+
diff --git a/tastydoc/documentation/scalaShadowing/language$.md b/tastydoc/documentation/scalaShadowing/language$.md
new file mode 100644
index 000000000000..da63363b3435
--- /dev/null
+++ b/tastydoc/documentation/scalaShadowing/language$.md
@@ -0,0 +1,186 @@
+scalaShadowing
+# object language
+
+final object language extends Serializable
+The `scala.language` object controls the language features available to the programmer, as proposed in the
+[**SIP-18 document**](https://docs.google.com/document/d/1nlkvpoIRkx7at1qJEZafJwthZ3GeIklTFhqmXMvTX9Q/edit).
+Each of these features has to be explicitly imported into the current scope to become available:
+```scala
+import language.postfixOps // or language._
+List(1, 2, 3) reverse
+```
+The language features are:
+* [`dynamics`](../scalaShadowing/language$.md#dynamics) enables defining calls rewriting using the `Dynamic` trait
+* [`postfixOps`](../scalaShadowing/language$.md#postfixOps) enables postfix operators
+* [`reflectiveCalls`](../scalaShadowing/language$.md#reflectiveCalls) enables using structural types
+* [`implicitConversions`](../scalaShadowing/language$.md#implicitConversions) enables defining implicit methods and members
+* [`higherKinds`](../scalaShadowing/language$.md#higherKinds) enables writing higher-kinded types
+* [`existentials`](../scalaShadowing/language$.md#existentials) enables writing existential types
+* `experimental` contains newer features that have not yet been tested in production
+
+and, for dotty:
+* `Scala2`] backwards compatibility mode for Scala2
+* `noAutoTupling` disable auto-tupling
+* `strictEquality` enable strick equality
+
+***production*** Language Features
+
+***experimental*** Experimental Language Features
+
+***experimental*** 10
+Dotty-specific features come at the end.
+Note: Due to the more restricted language import mechanism in dotty (only
+imports count, implicits are disregarded) we don't need the constructions
+of the inherited language features. A simple object for each feature is
+sufficient.
+
+## Concrete Type Members:
+### Scala2
+final object Scala2
+Where imported, a backwards compatibility mode for Scala2 is enabled
+
+### experimental
+final object experimental
+The experimental object contains features that have been recently added but have not
+been thoroughly tested in production yet.
+Experimental features **may undergo API changes** in future releases, so production
+code should not rely on them.
+Programmers are encouraged to try out experimental features and
+[report any bugs or API inconsistencies](http://issues.scala-lang.org)
+they encounter so they can be improved in future releases.
+
+***Group*** experimental
+
+### noAutoTupling
+final object noAutoTupling
+Where imported, auto-tupling is disabled
+
+### strictEquality
+final object strictEquality
+Where imported loose equality using eqAny is disabled
+
+## Concrete Value Members:
+### dynamics
+@volatile implicit val dynamics: dynamics
+Where enabled, direct or indirect subclasses of trait scala.Dynamic can
+be defined. Unless dynamics is enabled, a definition of a class, trait,
+or object that has Dynamic as a base trait is rejected. Dynamic member
+selection of existing subclasses of trait Dynamic are unaffected;
+they can be used anywhere.
+**Why introduce the feature?** To enable flexible DSLs and convenient interfacing
+with dynamic languages.
+**Why control it?** Dynamic member selection can undermine static checkability
+of programs. Furthermore, dynamic member selection often relies on reflection,
+which is not available on all platforms.
+
+***Group*** production
+
+
+### existentials
+@volatile implicit val existentials: existentials
+Only where enabled, existential types that cannot be expressed as wildcard
+types can be written and are allowed in inferred types of values or return
+types of methods. Existential types with wildcard type syntax such as `List[_]`,
+or `Map[String, _]` are not affected.
+**Why keep the feature?** Existential types are needed to make sense of Java’s wildcard
+types and raw types and the erased types of run-time values.
+**Why control it?** Having complex existential types in a code base usually makes
+application code very brittle, with a tendency to produce type errors with
+obscure error messages. Therefore, going overboard with existential types
+is generally perceived not to be a good idea. Also, complicated existential types
+might be no longer supported in a future simplification of the language.
+
+***Group*** production
+
+
+### higherKinds
+@volatile implicit val higherKinds: higherKinds
+Only where this flag is enabled, higher-kinded types can be written.
+**Why keep the feature?** Higher-kinded types enable the definition of very general
+abstractions such as functor, monad, or arrow. A significant set of advanced
+libraries relies on them. Higher-kinded types are also at the core of the
+scala-virtualized effort to produce high-performance parallel DSLs through staging.
+**Why control it?** Higher kinded types in Scala lead to a Turing-complete
+type system, where compiler termination is no longer guaranteed. They tend
+to be useful mostly for type-level computation and for highly generic design
+patterns. The level of abstraction implied by these design patterns is often
+a barrier to understanding for newcomers to a Scala codebase. Some syntactic
+aspects of higher-kinded types are hard to understand for the uninitiated and
+type inference is less effective for them than for normal types. Because we are
+not completely happy with them yet, it is possible that some aspects of
+higher-kinded types will change in future versions of Scala. So an explicit
+enabling also serves as a warning that code involving higher-kinded types
+might have to be slightly revised in the future.
+
+***Group*** production
+
+
+### implicitConversions
+@volatile implicit val implicitConversions: implicitConversions
+Only where enabled, definitions of legacy implicit conversions and certain uses
+of implicit conversions are allowed.
+A legacy implicit conversion is an implicit value of unary function type `A => B`,
+or an implicit method that has in its first parameter section a single,
+non-implicit parameter. Examples:
+```scala
+implicit def stringToInt(s: String): Int = s.length
+implicit val conv = (s: String) => s.length
+implicit def listToX(xs: List[T])(implicit f: T => X): X = ...
+```
+Implicit values of other types are not affected, and neither are implicit
+classes. In particular, delegates of the scala.Conversion class can be
+defined without having to import the language feature.
+The language import is also required to enable _uses_ of implicit conversions
+unless the conversion in question is co-defined with the type to which it maps.
+Co-defined means: defined in the companion object of the class of the result type.
+Examples:
+```scala
+class A
+class B
+object B {
+ delegate a2b for Conversion[A, B] { ... }
+}
+object C {
+ delegate b2a for Conversion[B, A] { ... }
+}
+import delegate B._
+import delegate C._
+val x: A = new B // language import required
+val x: B = new A // no import necessary since a2b is co-defined with B
+```
+**Why keep the feature?** Implicit conversions are central to many aspects
+of Scala’s core libraries.
+**Why control it?** Implicit conversions are known to cause many pitfalls
+if over-used. This holds in particular for implicit conversions defined after
+the fact between unrelated types.
+
+***Group*** production
+
+
+### postfixOps
+@volatile implicit val postfixOps: postfixOps
+Only where enabled, postfix operator notation `(expr op)` will be allowed.
+**Why keep the feature?** Several DSLs written in Scala need the notation.
+**Why control it?** Postfix operators interact poorly with semicolon inference.
+ Most programmers avoid them for this reason.
+
+***Group*** production
+
+
+### reflectiveCalls
+@volatile implicit val reflectiveCalls: reflectiveCalls
+Only where enabled, accesses to members of structural types that need
+reflection are supported. Reminder: A structural type is a type of the form
+`Parents { Decls }` where `Decls` contains declarations of new members that do
+not override any member in `Parents`. To access one of these members, a
+reflective call is needed.
+**Why keep the feature?** Structural types provide great flexibility because
+they avoid the need to define inheritance hierarchies a priori. Besides,
+their definition falls out quite naturally from Scala’s concept of type refinement.
+**Why control it?** Reflection is not available on all platforms. Popular tools
+such as ProGuard have problems dealing with it. Even where reflection is available,
+reflective dispatch can lead to surprising performance degradations.
+
+***Group*** production
+
+
diff --git a/tastydoc/documentation/scalaShadowing/language$/Scala2$.md b/tastydoc/documentation/scalaShadowing/language$/Scala2$.md
new file mode 100644
index 000000000000..9aef3c5499af
--- /dev/null
+++ b/tastydoc/documentation/scalaShadowing/language$/Scala2$.md
@@ -0,0 +1,6 @@
+scalaShadowing.language$
+# object Scala2
+
+final object Scala2 extends Serializable
+Where imported, a backwards compatibility mode for Scala2 is enabled
+
diff --git a/tastydoc/documentation/scalaShadowing/language$/experimental$.md b/tastydoc/documentation/scalaShadowing/language$/experimental$.md
new file mode 100644
index 000000000000..37ef07958dbb
--- /dev/null
+++ b/tastydoc/documentation/scalaShadowing/language$/experimental$.md
@@ -0,0 +1,27 @@
+scalaShadowing.language$
+# object experimental
+
+final object experimental extends Serializable
+The experimental object contains features that have been recently added but have not
+been thoroughly tested in production yet.
+Experimental features **may undergo API changes** in future releases, so production
+code should not rely on them.
+Programmers are encouraged to try out experimental features and
+[report any bugs or API inconsistencies](http://issues.scala-lang.org)
+they encounter so they can be improved in future releases.
+
+***Group*** experimental
+
+## Concrete Value Members:
+### macros
+@volatile implicit val macros: macros
+Where enabled, macro definitions are allowed. Macro implementations and
+macro applications are unaffected; they can be used anywhere.
+**Why introduce the feature?** Macros promise to make the language more regular,
+replacing ad-hoc language constructs with a general powerful abstraction
+capability that can express them. Macros are also a more disciplined and
+powerful replacement for compiler plugins.
+**Why control it?** For their very power, macros can lead to code that is hard
+to debug and understand.
+
+
diff --git a/tastydoc/documentation/scalaShadowing/language$/noAutoTupling$.md b/tastydoc/documentation/scalaShadowing/language$/noAutoTupling$.md
new file mode 100644
index 000000000000..c8fc43c6e402
--- /dev/null
+++ b/tastydoc/documentation/scalaShadowing/language$/noAutoTupling$.md
@@ -0,0 +1,6 @@
+scalaShadowing.language$
+# object noAutoTupling
+
+final object noAutoTupling extends Serializable
+Where imported, auto-tupling is disabled
+
diff --git a/tastydoc/documentation/scalaShadowing/language$/strictEquality$.md b/tastydoc/documentation/scalaShadowing/language$/strictEquality$.md
new file mode 100644
index 000000000000..6ca3fcd9d99d
--- /dev/null
+++ b/tastydoc/documentation/scalaShadowing/language$/strictEquality$.md
@@ -0,0 +1,6 @@
+scalaShadowing.language$
+# object strictEquality
+
+final object strictEquality extends Serializable
+Where imported loose equality using eqAny is disabled
+
diff --git a/tastydoc/documentation/scalaShadowing/scalaShadowing.md b/tastydoc/documentation/scalaShadowing/scalaShadowing.md
new file mode 100644
index 000000000000..ebd0406415d5
--- /dev/null
+++ b/tastydoc/documentation/scalaShadowing/scalaShadowing.md
@@ -0,0 +1,69 @@
+# Package scalaShadowing
+## Members:
+final object language
+The `scala.language` object controls the language features available to the programmer, as proposed in the
+[**SIP-18 document**](https://docs.google.com/document/d/1nlkvpoIRkx7at1qJEZafJwthZ3GeIklTFhqmXMvTX9Q/edit).
+Each of these features has to be explicitly imported into the current scope to become available:
+```scala
+import language.postfixOps // or language._
+List(1, 2, 3) reverse
+```
+The language features are:
+* [`dynamics`](../scalaShadowing/language$.md#dynamics) enables defining calls rewriting using the `Dynamic` trait
+* [`postfixOps`](../scalaShadowing/language$.md#postfixOps) enables postfix operators
+* [`reflectiveCalls`](../scalaShadowing/language$.md#reflectiveCalls) enables using structural types
+* [`implicitConversions`](../scalaShadowing/language$.md#implicitConversions) enables defining implicit methods and members
+* [`higherKinds`](../scalaShadowing/language$.md#higherKinds) enables writing higher-kinded types
+* [`existentials`](../scalaShadowing/language$.md#existentials) enables writing existential types
+* `experimental` contains newer features that have not yet been tested in production
+
+and, for dotty:
+* `Scala2`] backwards compatibility mode for Scala2
+* `noAutoTupling` disable auto-tupling
+* `strictEquality` enable strick equality
+
+***production*** Language Features
+
+***experimental*** Experimental Language Features
+
+***experimental*** 10
+Dotty-specific features come at the end.
+Note: Due to the more restricted language import mechanism in dotty (only
+imports count, implicits are disregarded) we don't need the constructions
+of the inherited language features. A simple object for each feature is
+sufficient.
+
+final val language: language
+The `scala.language` object controls the language features available to the programmer, as proposed in the
+[**SIP-18 document**](https://docs.google.com/document/d/1nlkvpoIRkx7at1qJEZafJwthZ3GeIklTFhqmXMvTX9Q/edit).
+Each of these features has to be explicitly imported into the current scope to become available:
+```scala
+import language.postfixOps // or language._
+List(1, 2, 3) reverse
+```
+The language features are:
+* `dynamics` enables defining calls rewriting using the `Dynamic` trait
+* `postfixOps` enables postfix operators
+* `reflectiveCalls` enables using structural types
+* `implicitConversions` enables defining implicit methods and members
+* `higherKinds` enables writing higher-kinded types
+* `existentials` enables writing existential types
+* `experimental` contains newer features that have not yet been tested in production
+
+and, for dotty:
+* `Scala2`] backwards compatibility mode for Scala2
+* `noAutoTupling` disable auto-tupling
+* `strictEquality` enable strick equality
+
+***production*** Language Features
+
+***experimental*** Experimental Language Features
+
+***experimental*** 10
+Dotty-specific features come at the end.
+Note: Due to the more restricted language import mechanism in dotty (only
+imports count, implicits are disregarded) we don't need the constructions
+of the inherited language features. A simple object for each feature is
+sufficient.
+
+
diff --git a/tastydoc/input/project/build.properties b/tastydoc/input/project/build.properties
new file mode 100644
index 000000000000..0cd8b07982e1
--- /dev/null
+++ b/tastydoc/input/project/build.properties
@@ -0,0 +1 @@
+sbt.version=1.2.3
diff --git a/tastydoc/input/src/main/scala/example/Documentation2.scala b/tastydoc/input/src/main/scala/example/Documentation2.scala
new file mode 100644
index 000000000000..52eb51f348cc
--- /dev/null
+++ b/tastydoc/input/src/main/scala/example/Documentation2.scala
@@ -0,0 +1,12 @@
+package example
+
+class ReturnTypeClass[T] {
+}
+
+class UserDocLinkingClass {
+ def linkMeFromUserDoc() = ???
+}
+
+object ReturnObjectWithType {
+ type returnType = Int
+}
\ No newline at end of file
diff --git a/tastydoc/input/src/main/scala/example/Inheritance.scala b/tastydoc/input/src/main/scala/example/Inheritance.scala
new file mode 100644
index 000000000000..0ae4f4f5ab2d
--- /dev/null
+++ b/tastydoc/input/src/main/scala/example/Inheritance.scala
@@ -0,0 +1,5 @@
+package example
+
+import example.level2.Documentation
+
+abstract class DocumentationInheritance[T, A <: Int, B >: String, -X, +Y] extends Documentation[T, A, B, X, Y] {}
\ No newline at end of file
diff --git a/tastydoc/input/src/main/scala/example/level2/Documentation.scala b/tastydoc/input/src/main/scala/example/level2/Documentation.scala
new file mode 100644
index 000000000000..e6f8a3f73f98
--- /dev/null
+++ b/tastydoc/input/src/main/scala/example/level2/Documentation.scala
@@ -0,0 +1,161 @@
+package example
+/** Test
+*/
+package level2
+
+import scala.collection._
+import scala.deprecated
+import scala.annotation._
+import scala.math.{Pi, max}
+
+/** This class is used for testing tasty doc generation
+ * @constructor create new object
+ * @author Bryan Abate
+ * @param c1 class parameter 1
+ * @param c2 class parameter 2
+ * @tparam T class type parameter
+ */
+@strictfp
+abstract class Documentation[T, A <: Int, B >: String, -X, +Y](c1: String, val c2: List[T]) extends Seq[T] with Product with Serializable{
+
+ /** Auxiliary constructor
+ * @param ac auxiliary parameter
+ */
+ def this(ac: String) = this(ac, Nil)
+
+ def this() = this("", Nil)
+
+ def this(x: T) = this()
+
+ class innerDocumentationClass {
+
+ }
+
+ sealed trait CaseImplementThis(id: Int)
+ case class IAmACaseClass(x: T, id: Int) extends CaseImplementThis(id)
+ case object IAmACaseObject extends CaseImplementThis(0)
+
+ object testObject {
+
+ }
+
+ def defReturningInnerClass(): innerDocumentationClass = ???
+
+ /** Test methods with params
+ *
+ * @param x parameter 1
+ * @param y parameter 2
+ *
+ * @return something is returned
+ */
+ def methodsWithParams(x : T, y: Int) : List[Map[Int, T]] = ???
+
+ def methodsWithImplicit(x: Int)(implicit imp: Int, notImp: String) = ???
+
+ def methodsWithCallByName(x: => Int) = ???
+
+ def methodsWithDefault(x: Int = 42) = ???
+
+ class Graph {
+ type Node = Int
+ }
+ def linkingGraph(g: Graph): g.Node = ???
+
+ val refinementTest:
+ Graph {
+ //def x(a: String, b: Double)(c: Float): Int
+ def x: Int
+ def x2: innerDocumentationClass
+ type Y = String
+ val z: Boolean
+ }
+
+ /** Test value
+ */
+ @showAsInfix
+ val v : Int = ???
+
+ protected def protectedMethod = ???
+ private def privateMethod = ???
+
+ protected val protectedVal = ???
+ private val privateVal = ???
+
+ def abstractDefinition : Int
+
+ def apply(idx: Int) = ???
+ def iterator = ???
+ override def length = ???
+
+ /** method: [[example.UserDocLinkingClass.linkMeFromUserDoc]]
+ *
+ * method:[[example.level2.Documentation.apply]]
+ *
+ * class: [[example.UserDocLinkingClass]]
+ */
+ def linkMethodInDoc() = ???
+
+ /** An example documention with markdown formatting
+ *
+ * **I'm bold**
+ *
+ * *I'm italic*
+ *
+ * `some code`
+ * ```scala
+ * def someScalaCode(x: String) = println("Hello " + x)
+ * ```
+ *
+ *# Title of level 1
+ *# Title of level 1
+ *
+ * 1. I'm a list
+ *
+ *
+ * * Multilevel List
+ * 1. level 2
+ * 1. level 2 2
+ * * level 1 again
+ *
+ * * multilevel try2
+ * * try2 level2
+ */
+ def docWithMd = ???
+
+ def functionWithType[U >: String]() : U
+
+ val complexTypeVal : Int | List[List[T]] & String | (Double | Int, Double) | ((Int) => (String))
+
+ type typeExample[X] >: X <: String //TypeBound
+
+ type abstractType
+
+ def useOfOutsideType(): ReturnTypeClass[T] = ???
+ def useOfOutsideTypeInsideObject(): ReturnObjectWithType.returnType = ???
+ def useOfSameLevelOutsideType(): SameLevelTypeLinking = ???
+
+ protected[example] val valWithScopeModifier = ???
+ protected[this] val valWithScopeModifierThis = ???
+
+ var iAmAVar = ???
+}
+
+/** Companion object
+ */
+object Documentation {
+ val valInsideDocObject = ???
+}
+
+sealed abstract class ClassExtendingDocumentation[T, A <: Int, B >: String, -X, +Y] extends Documentation[T, A, B, X, Y] {}
+
+trait TraitTest {
+
+}
+
+val valueInAPackage = 0
+
+def defInAPackage(abc: String): List[Int] = ???
+
+trait TraitWithCompanion{}
+
+object TraitWithCompanion{}
\ No newline at end of file
diff --git a/tastydoc/input/src/main/scala/example/level2/SameLevelTypeLinking.scala b/tastydoc/input/src/main/scala/example/level2/SameLevelTypeLinking.scala
new file mode 100644
index 000000000000..5294185e487a
--- /dev/null
+++ b/tastydoc/input/src/main/scala/example/level2/SameLevelTypeLinking.scala
@@ -0,0 +1,5 @@
+package example.level2
+
+class SameLevelTypeLinking {
+
+}
\ No newline at end of file
diff --git a/tastydoc/input/src/main/scala/example/level2/level3/level4/ClassLevel4.scala b/tastydoc/input/src/main/scala/example/level2/level3/level4/ClassLevel4.scala
new file mode 100644
index 000000000000..40d962fc43e1
--- /dev/null
+++ b/tastydoc/input/src/main/scala/example/level2/level3/level4/ClassLevel4.scala
@@ -0,0 +1,13 @@
+package example.level2.level3.level4
+
+import example.level2.Documentation
+
+sealed abstract class ClassLevel4[T, A <: Int, B >: String, -X, +Y]() extends Documentation[T, A, B, X, Y] {
+
+ /**
+ * [[example.level2.Documentation]]
+ * [[example.level2.Documentation$.valInsideDocObject]]
+ * [[example.level2.Documentation.abstractType]]
+ */
+ def linkingToDocMethodInUserDoc = ???
+}
\ No newline at end of file
diff --git a/tastydoc/project/build.properties b/tastydoc/project/build.properties
new file mode 100644
index 000000000000..72f902892a13
--- /dev/null
+++ b/tastydoc/project/build.properties
@@ -0,0 +1 @@
+sbt.version=1.2.7
diff --git a/tastydoc/readme.md b/tastydoc/readme.md
new file mode 100644
index 000000000000..436600045d9a
--- /dev/null
+++ b/tastydoc/readme.md
@@ -0,0 +1,11 @@
+# Tastydoc
+
+This tool produces Markdown documentation files for Scala projects using TASTy files.
+
+## How to run
+Call main with the following arguments to produce Markdown documentation files:
+* **[--syntax SYNTAX]** Syntax for parsing user documentation (either *wiki or markdown*)
+* **[--packagestolink REGEXES...]** Regexes of packages or entities (example: `scala.collection.*`). Only the types with a path matching these regexes will produce links in the documentation files
+* **[--classpath URI]** Extra classpath for input files
+* **[-i FILES...]** TASTy files
+* **[-d DIRECTORIES...]** Directories to recursively find TASTy files
\ No newline at end of file
diff --git a/tastydoc/report/presentation/images/dottypredef.png b/tastydoc/report/presentation/images/dottypredef.png
new file mode 100644
index 000000000000..5528745cb3b3
Binary files /dev/null and b/tastydoc/report/presentation/images/dottypredef.png differ
diff --git a/tastydoc/report/presentation/images/language.png b/tastydoc/report/presentation/images/language.png
new file mode 100644
index 000000000000..dfeed596705b
Binary files /dev/null and b/tastydoc/report/presentation/images/language.png differ
diff --git a/tastydoc/report/presentation/images/reflection.png b/tastydoc/report/presentation/images/reflection.png
new file mode 100644
index 000000000000..48f5dab94c73
Binary files /dev/null and b/tastydoc/report/presentation/images/reflection.png differ
diff --git a/tastydoc/report/presentation/presentation.pdf b/tastydoc/report/presentation/presentation.pdf
new file mode 100644
index 000000000000..d8cbf43a76ef
Binary files /dev/null and b/tastydoc/report/presentation/presentation.pdf differ
diff --git a/tastydoc/report/presentation/presentation.tex b/tastydoc/report/presentation/presentation.tex
new file mode 100644
index 000000000000..263ea0bb3528
--- /dev/null
+++ b/tastydoc/report/presentation/presentation.tex
@@ -0,0 +1,230 @@
+\documentclass{beamer}
+\usepackage{textcomp}
+\usepackage{listings}
+\usepackage{tikz}
+\usetikzlibrary{shapes.geometric, arrows, positioning, shadows}
+\tikzstyle{process} = [rectangle, minimum width=3cm, minimum height=1cm, text centered, text width=6cm, draw=black]
+\tikzstyle{arrow} = [thick,->,>=stealth]
+\lstset{
+ backgroundcolor=\color{white}, % choose the background color; you must add \usepackage{color} or \usepackage{xcolor}; should come as last argument
+ basicstyle=\footnotesize, % the size of the fonts that are used for the code
+ breakatwhitespace=false, % sets if automatic breaks should only happen at whitespace
+ breaklines=true, % sets automatic line breaking
+ captionpos=b, % sets the caption-position to bottom
+ commentstyle=\color{green}, % comment style
+ escapeinside={\%*}{*)}, % if you want to add LaTeX within your code
+ extendedchars=true, % lets you use non-ASCII characters; for 8-bits encodings only, does not work with UTF-8
+ frame=single, % adds a frame around the code
+ keepspaces=true, % keeps spaces in text, useful for keeping indentation of code (possibly needs columns=flexible)
+ keywordstyle=\color{blue}, % keyword style
+ language=Scala, % the language of the code
+ numbers=none, % where to put the line-numbers; possible values are (none, left, right)
+ rulecolor=\color{black}, % if not set, the frame-color may be changed on line-breaks within not-black text (e.g. comments (green here))
+ showspaces=false, % show spaces everywhere adding particular underscores; it overrides 'showstringspaces'
+ showstringspaces=false, % underline spaces within strings only
+ showtabs=false, % show tabs within strings adding particular underscores
+ stepnumber=2, % the step between two line-numbers. If it's 1, each line will be numbered
+ stringstyle=\color{purple}, % string literal style
+ tabsize=2, % sets default tabsize to 2 spaces
+ title=\lstname % show the filename of files included with \lstinputlisting; also try caption instead of title
+}
+\usepackage[utf8]{inputenc}
+\usepackage{graphicx}
+\beamertemplatenavigationsymbolsempty
+%\usetheme{CambridgeUS}
+%\usefonttheme{professionalfonts}
+\usecolortheme{beaver}
+
+%Information to be included in the title page:
+\title{Tastydoc}
+\subtitle{A documentation tool for Dotty using TASTy files}
+\author{Bryan Abate}
+\date{19th June 2019}
+
+\begin{document}
+
+\frame{\titlepage}
+
+\begin{frame}
+ \frametitle{Table of Contents}
+ \tableofcontents
+\end{frame}
+
+\AtBeginSection[]
+{
+ \begin{frame}
+ \frametitle{Table of Contents}
+ \tableofcontents[currentsection]
+ \end{frame}
+}
+
+\section{Introduction}
+
+\begin{frame}
+ \frametitle{What is Tastydoc ?}
+ \begin{itemize}
+ \item Documentation tool for Dotty
+ \item Uses TASTy files
+ \item Outputs Markdown
+ \end{itemize}
+\end{frame}
+
+\section{Features}
+
+\begin{frame}
+ \frametitle{Accessible information}
+ \begin{itemize}
+ \item Annotations, modifiers (including scope modifiers), parameters, type parameters, and return types
+ \item Members, parents, constructors, known subclasses and companion
+ \item User documentation (Wiki-style \& Markdown)
+ \item Reference for linking
+ \end{itemize}
+\end{frame}
+
+\begin{frame}
+ \frametitle{TASTy}
+ \begin{itemize}
+ \item Extract information from them
+ \item Independent from the compiler
+ \end{itemize}
+\end{frame}
+
+\begin{frame}
+ \frametitle{Markdown}
+ \begin{itemize}
+ \item Easy to edit by hand \& preview
+ \item Easy to add own files
+ \item Easy for the user to make links
+ \item Git hosting services have built-in preview
+ \item Easy to convert to another format (HTML, PDF, etc.)
+ \end{itemize}
+\end{frame}
+
+\section{Examples}
+
+\begin{frame}
+ \frametitle{Example: scala.tasty.Reflection}
+ \begin{center}
+ \includegraphics[width=\textwidth,height=0.9\textheight,keepaspectratio]{images/reflection.png}
+ \end{center}
+\end{frame}
+
+\begin{frame}
+ \frametitle{Example: dotty.DottyPredef}
+ \begin{center}
+ \includegraphics[width=\textwidth,height=0.9\textheight,keepaspectratio]{images/dottypredef.png}
+ \end{center}
+\end{frame}
+\begin{frame}
+ \frametitle{Example: scalaShadowing.language}
+ \begin{center}
+ \includegraphics[width=\textwidth,height=0.9\textheight,keepaspectratio]{images/language.png}
+ \end{center}
+\end{frame}
+
+\section{Architecture}
+
+\begin{frame}
+ \frametitle{Workflow}
+
+ \begin{center}
+ \begin{tikzpicture}[node distance=2cm]
+ \node (parse) [process] {Parse command line arguments};
+ \node (convert) [process, below of=parse] {Convert TASTy files to Representations while keeping track of seen packages};
+ \draw [arrow] (parse) -- (convert);
+ \node (output) [process, below of=convert] {Traverse Representations, parse user documentation, format output and write to files};
+
+ \draw [arrow] (convert) -- (output);
+ \end{tikzpicture}
+ \end{center}
+\end{frame}
+
+\begin{frame}
+ \frametitle{Representation}
+
+ \begin{itemize}
+ \item Contain information about an entity
+ \item Easy to use, no knowledge of TASTy required
+ \item Code is easy to maintain
+ \item Similar to Dottydoc Entity \textrightarrow can reuse Dottydoc code
+ \end{itemize}
+\end{frame}
+
+\begin{frame}
+ \frametitle{Reference}
+ \begin{itemize}
+ \item Contain information about types
+ \item Necessary for linking
+ \item Inspired by Dottydoc
+ \end{itemize}
+\end{frame}
+
+\section{Dottydoc vs Tastydoc}
+
+\begin{frame}
+ \frametitle{Extra features}
+ \begin{itemize}
+ \item Scope modifiers
+ \item Known subclasses
+ \item Refined types
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Bugs fixed}
+ \begin{itemize}
+ \item Buggy output
+\begin{lstlisting}
+final val BITS_PER_LAZY_VAL : [31m2L[0m
+\end{lstlisting}
+ \item Wrong parents
+ \item Annotations
+ \item Compiler artifacts \pause
+ \item potentially program breaking code
+\begin{lstlisting}[language=scala]
+def parents: List[Entity] = this :: this.parents
+\end{lstlisting}
+ \end{itemize}
+\end{frame}
+
+\section{Problems \& Further work}
+
+\begin{frame}
+ \frametitle{Problems}
+
+ \begin{itemize}
+ \item Markdown escaping
+ \item Linking inside code blocks
+ \item Sections
+ \item IDs for linking
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Further work}
+
+ \begin{itemize}
+ \item Markdown escaping
+ \item Type lambdas
+ \item Complex types
+\begin{lstlisting}[language=scala]
+ class Graph {
+ type Node = Int
+ }
+ def linkingGraph(g: Graph): g.Node = ???
+\end{lstlisting}
+ \item Default values
+ \item Extra user-documentation parsing
+ \item HTML/CSS
+ \end{itemize}
+\end{frame}
+
+\begin{frame}
+ \begin{center}
+ \Huge{Questions ?}
+ \end{center}
+\end{frame}
+
+\end{document}
+
+% Pull request is waiting?
\ No newline at end of file
diff --git a/tastydoc/report/report.pdf b/tastydoc/report/report.pdf
new file mode 100644
index 000000000000..2de1b08f254c
Binary files /dev/null and b/tastydoc/report/report.pdf differ
diff --git a/tastydoc/report/report.tex b/tastydoc/report/report.tex
new file mode 100644
index 000000000000..b8a443e1c39f
--- /dev/null
+++ b/tastydoc/report/report.tex
@@ -0,0 +1,348 @@
+\documentclass{report}
+\usepackage{listings}
+\usepackage[dvipsnames]{xcolor}
+
+\lstset{
+ backgroundcolor=\color{white}, % choose the background color; you must add \usepackage{color} or \usepackage{xcolor}; should come as last argument
+ basicstyle=\footnotesize, % the size of the fonts that are used for the code
+ breakatwhitespace=false, % sets if automatic breaks should only happen at whitespace
+ breaklines=true, % sets automatic line breaking
+ captionpos=b, % sets the caption-position to bottom
+ commentstyle=\color{green}, % comment style
+ escapeinside={\%*}{*)}, % if you want to add LaTeX within your code
+ extendedchars=true, % lets you use non-ASCII characters; for 8-bits encodings only, does not work with UTF-8
+ frame=single, % adds a frame around the code
+ keepspaces=true, % keeps spaces in text, useful for keeping indentation of code (possibly needs columns=flexible)
+ keywordstyle=\color{blue}, % keyword style
+ language=Scala, % the language of the code
+ numbers=none, % where to put the line-numbers; possible values are (none, left, right)
+ rulecolor=\color{black}, % if not set, the frame-color may be changed on line-breaks within not-black text (e.g. comments (green here))
+ showspaces=false, % show spaces everywhere adding particular underscores; it overrides 'showstringspaces'
+ showstringspaces=false, % underline spaces within strings only
+ showtabs=false, % show tabs within strings adding particular underscores
+ stepnumber=2, % the step between two line-numbers. If it's 1, each line will be numbered
+ stringstyle=\color{purple}, % string literal style
+ tabsize=2, % sets default tabsize to 2 spaces
+ title=\lstname % show the filename of files included with \lstinputlisting; also try caption instead of title
+}
+
+\usepackage{hyperref}
+\usepackage{tikz}
+\usetikzlibrary{shapes.geometric, arrows, positioning}
+\tikzstyle{process} = [rectangle, minimum width=3cm, minimum height=1cm, text centered, text width=6cm, draw=black]
+\tikzstyle{arrow} = [thick,->,>=stealth]
+
+\begin{document}
+
+\title{Tastydoc: a documentation tool for Dotty using TASTy files}
+\author{Bryan Abate
+\\\\\small{Supervised by Aleksander Boruch-Gruszecki}}
+
+\maketitle
+
+\begin{abstract}
+The current documentation tool (Dottydoc) relies on compiler internals and low-level code. The tool introduced in this work aims to build a program that does not depend on compiler internals but instead uses TASTy files. The latter become output when a Scala program is compiled.
+
+This work also aims at providing a better-maintained tool with fewer bugs and more features.
+
+The documentation files are in Markdown instead of the commonly used HTML.
+\end{abstract}
+
+\tableofcontents
+
+\chapter{Introduction}
+
+The repository for this project can be found here: \url{https://github.com/BryanAbate/dotty/tree/tastydoc/tastydoc}.
+
+And the documentation of Dotty generated with this tool here: \url{https://github.com/BryanAbate/dotty/tree/tastydoc/tastydoc/documentation}.
+
+A documentation tool is a program generating information (often in the form of HTML files) about projects. Usually, that tool includes method signatures, user-written documentation, links to other pages of the documentation, etc.
+In Dotty, the current tool for generating Scala projects documentation is called Dottydoc. The tool introduced here, Tastydoc, aims to improve on Dottydoc and replace it.
+
+Tastydoc uses TASTy files. These files contain information about the source code of a program. They become output when a program is compiled. Tastydoc consumes such files to extract information about the code, making its use completely independent of the compiler.
+The tool tries to be as close as possible to the structure proposed in Dottydoc so that it can reuse some portions of its code with minor modifications.
+
+The documentation is often output as HTML files, but here we choose to output Markdown files for reasons detailed further in the report.
+
+The tool was developed with a few goals in mind. First, it should be independent of the compiler, hence the use of TASTy files. It should also produce humanly consumable files, hence the choice of Markdown as an output. Finally, it should have as many features as Dottydoc and be as easily maintainable.
+
+The report is organized in the following structure: First, we will talk about the features of the tool. Then, we will give a high-level and low-level architectural description. Dottydoc and Tastydoc will then be compared. We will finally talk about the problems encountered during the development and the further work needed.
+
+\chapter{Features}
+We will list here the most important features of Tastydoc. For a comparison with Dottydoc features see \autoref{sec:comparison}.
+
+\paragraph{Accessible information}
+The tool has knowledge of the full signature of entities; that is, awareness of annotations, modifiers (including scope modifiers), parameters, type parameters, and return types.
+
+For classes, traits, and objects the following are also available (when applicable): members, parents, constructors, known subclasses and companion.
+Packages know all their members as long as all corresponding TASTy files are passed as arguments to the tool.
+
+User-written documentation, including individual access to defined @ such as \texttt{@param} (except \texttt{@usecase}) is available. Two syntaxes are supported, which are the old Scaladoc Wiki-style syntax as well as Dottydoc Markdown syntax. Linking to entities (classes, methods, etc.) is possible inside the user documentation in the Wiki-style syntax using the notation like \texttt{[[scala.foo.bar]]}.
+
+\paragraph{TASTy}
+The tool relies on consuming TASTy files and is hence independent from the compiler.
+
+\paragraph{Linking}
+Tastydoc is able to produce links to types defined outside of the current TASTy files (as well as the one inside the file). This is particularly useful for linking to the types of the parameters and the return types, companions, annotations, scope modifiers, and parents.
+
+\paragraph{Markdown}
+Outputting Markdown instead of HTML has several advantages. It is easy to edit by hand, easily previewed, and users can easily add their own texts or files to it. A user could, for example, write a Markdown file and link it in the documentation of a class or do the opposite and link a documentation page in a Markdown file.
+
+Markdown files can easily be uploaded for preview to GitHub or GitLab. In that way, it is very easy to upload documentation files along with the code of a project.
+
+Additionally, a lot of tools are available to consume Markdown files and output other formats such as HTML or PDF, making Markdown a nice intermediate representation. We can then imagine a pipeline like this:
+\begin{center}
+ \begin{tikzpicture}[node distance=2cm]
+ \node (write) [process] {User writes code and documentation};
+ \node (compile) [process, below of=write] {Compiler produces TASTy files};
+ \node (tool) [process, below of=compile] {Tastydoc consumes TASTy files and produces Markdown};
+ \node (user) [process, below of=tool] {User edits Markdown files or add files as he wishes};
+ \node (HTML) [process, below of=user, right of=user, xshift=1.2cm] {Markdown files are consumed and transformed to another format(HTML, PDF, etc.)};
+ \node (upload) [process, below of=user, left of=user, xshift=-1.2cm] {Markdown files are uploaded to a git hosting service or a website};
+
+ \draw [arrow] (write) -- (compile);
+ \draw [arrow] (compile) -- (tool);
+ \draw [arrow] (tool) -- (user);
+ \draw [arrow] (user) -- (HTML);
+ \draw [arrow] (user) -- (upload);
+ \end{tikzpicture}
+\end{center}
+
+\chapter{Architecture}
+\section{High-level architectural descriptions}
+\subsection{TASTy}
+TASTy is a data format aimed at serializing compiler information about code. Dotty produces these files for each class, object without companion class or trait, trait and package if it contains something else than classes, traits or objects. Given its nature, TASTy is perfect to extract information.
+This is done through the use of the reflect API and the making of a class extending \texttt{TastyConsumer}\footnote{\texttt{scala/tasty/file/TastyConsumer.scala}}.
+
+\subsection{High-level API}
+The tool offers an interface that is easy to use (called Representation, see \autoref{sec:representation}) to access all the information about an entity in a comprehensible format for anyone willing to write their own documentation tool without worrying to consume TASTy files.
+
+\subsection{Reuse of Dottydoc intermediate representation}
+The intermediate structure (Representation) is similar to Dottydoc \texttt{Entity}\footnote{\texttt{dotty/tools/dottydoc/Entity.scala}} allowing to easily reuse parts of Dottydoc code with only minor modifications. Right now, the tool uses parts of Dottydoc code for parsing user documentation. However, it could produce the same HTML files as Dottydoc without relying on compiler internals. Especially since Dottydoc already has a complex templating mechanism that allows attaching blog posts to documentation and a search engine.
+
+\section{Low-level architecture}
+\subsection{TastyExtractor}
+File: \texttt{dotty/tastydoc/TastyExtractor.scala}
+
+A trait containing useful methods for extracting information from the reflect API.
+
+\subsection{References}
+File: \texttt{dotty/tastydoc/references.scala}
+
+Object containing case classes. References are classes containing information about a specific type to be able to link to its documentation file later on. This is inspired by Dottydoc Reference\footnote{dotty/tools/dottydoc/model/references.scala}. There is a reference for all the existing special types such as "or type". Referencing a user-defined type (such as a class or a type alias) is done using a label (the name of the type, like "String") and a path (the full path in which it is defined, like "/scala/Predef/").
+
+\subsection{TastyTypeConverter}
+File: \texttt{dotty/tastydoc/TastyTypeConverter.scala}
+
+Trait containing methods for converting from Reflect types to References.
+
+\subsection{Representation}
+\label{sec:representation}
+File: \texttt{dotty/tastydoc/representations.scala}
+
+Object implementing both \texttt{TastyExtractor} and \texttt{TastyTypeConverter} and containing classes.
+
+A Representation contains all the information of a specific entity. The logic is as follows: there are different traits such as \texttt{Modifiers} or \texttt{Members} and classes which implement those traits. That logic is inspired by dotty-doc Entities\footnote{\texttt{dotty/tools/dottydoc/Entity.scala}}.
+
+A Representation take a reflect class such as \texttt{reflect.ClassDef} and extract every information from it using mostly \texttt{TastyExtractor} methods while converting types to References using \texttt{TastyTypeConverter} methods.
+
+Representations then can be easily used for printing: their content is self-explanatory and their use requires no knowledge of TASTy as the implementation is not exposed from the outside.
+
+We give below the existing Representation, a quick description and their signature (without parameters).
+\begin{itemize}
+ \item \texttt{PackageRepresentation} For packages
+\begin{lstlisting}[language=scala]
+class PackageRepresentation(...)
+extends Representation with Members
+\end{lstlisting}
+ \item \texttt{ImportRepresentation} For imports, never used in the tool
+\begin{lstlisting}[language=scala]
+class ImportRepresentation(...)
+extends Representation
+\end{lstlisting}
+ \item \texttt{ClassRepresentation} For classes, objects and traits, including case classes and case objects.
+\begin{lstlisting}[language=scala]
+class ClassRepresentation(...)
+extends Representation with Members
+with Parents with Modifiers with Companion
+with Constructors with TypeParams
+\end{lstlisting}
+ \item \texttt{DefRepresentation} For defs
+\begin{lstlisting}[language=scala]
+class DefRepresentation(...)
+extends Representation with Modifiers
+with TypeParams with MultipleParamList
+with ReturnValue
+\end{lstlisting}
+ \item \texttt{ValRepresentation} For vals and vars
+\begin{lstlisting}[language=scala]
+class ValRepresentation(...)
+extends Representation with Modifiers
+with ReturnValue
+\end{lstlisting}
+ \item \texttt{TypeRepresentation} For type alias
+\begin{lstlisting}[language=scala]
+class TypeRepresentation(...)
+extends Representation with Modifiers
+with TypeParams
+\end{lstlisting}
+ \item \texttt{EmulatedPackageRepresentation} This Representation allows to regroup every PackageRepresentation of the same package under the same Representation. In fact, Tasty will output a Tasty file for each entity in a package and the top of the \texttt{reflect.Tree} is a \texttt{reflect.PackageClause}. Thus, there will be multiple \texttt{PackageRepresentation} of the same package when converting multiple classes of the same package. That latter point can be problematic in regard to usability. This Representation counters that issue. When using an \texttt{EmulatedPackageRepresentation}, it looks to the user as if he were using a \texttt{PackageRepresentation} containing all the members of the package.
+\end{itemize}
+
+\subsection{DocPrinter}
+File: \texttt{dotty/tastydoc/DocPrinter.scala}
+
+Object with methods that formats Representations and References to Markdown and writes them to files. Basically, it handles all the formatting and writing logic of the tool.
+
+\subsection{mdscala}
+File: \texttt{dotty/tastydoc/mdscala.scala}
+
+Object that has helper methods for outputting Markdown. Unfortunately, it does not handle escaping as it is a non-trivial task and would require a significant amount of time (see \autoref{sec:problems}).
+
+\subsection{TastyDocConsumer}
+File: \texttt{dotty/tastydoc/TastyDocConsumer.scala}
+
+Extends TastyConsumer and consumes TASTy files to produce Representations. It needs a \texttt{mutable.HashMap[String, EmulatedPackageRepresentation]} as arguments for adding every new seen package to the map. This behaviour is required for two reasons: to link inside user documentation and to have a data structure for storing converted Representations.
+\subsection{Main}
+File: \texttt{dotty/tastydoc/Main.scala}
+
+Manages the workflow (see \autoref{sec:workflow}).
+
+Command line parameters are:
+\begin{itemize}
+ \item \textbf{\texttt{[--syntax SYNTAX]}} Syntax to use for user documentation parsing (either \textit{wiki} or \textit{markdown})
+ \item \textbf{\texttt{[--packagestolink REGEXES...]}} Regexes of packages or entities (example: \texttt{scala.collection.*}). Only the types with a path matching these regexes will produce links in the documentation files
+ \item \textbf{\texttt{[--classpath URI]}} Extra classpath for input files
+ \item \textbf{\texttt{[-i FILES...]}} TASTy files
+ \item \textbf{\texttt{[-d DIRECTORIES...]}} Directories to recursively find TASTy files
+\end{itemize}
+
+\subsection{User documentation parsing}
+Files are in the package \texttt{dotty.tastydoc.comment}.
+
+These files are taken from Dottydoc (modified to work with this architecture and output Markdown instead of HTML) and are responsible for parsing user-written documentation.
+
+Note that it uses a library called flexmark-java\footnote{\url{https://github.com/vsch/flexmark-java}} for parsing user documentation written in Markdown.
+
+\section{Workflow}
+\label{sec:workflow}
+Main workflow is as follows:
+
+\begin{center}
+ \begin{tikzpicture}[node distance=2cm]
+ \node (parse) [process] {Parse command line arguments};
+ \node (convert) [process, below of=parse] {Convert TASTy files to Representations while keeping track of seen packages};
+ \node (output) [process, below of=convert] {Traverse Representations, parse user documentation, format output and write to files};
+
+ \draw [arrow] (parse) -- (convert);
+ \draw [arrow] (convert) -- (output);
+ \end{tikzpicture}
+\end{center}
+
+As we can see, parsing user documentation is only done after converting to Representation. Indeed, in order to link methods, classes, etc. from user documentation we need to have first converted everything to Representation because the Wiki-style syntax does not tell us what is linked (a method? a class? an object?).
+
+
+\chapter{Comparison between Dottydoc and Tastydoc}
+Here we compare Dottydoc and Tastydoc in terms of features, bugs, and output.
+
+\section{General comparison}
+\label{sec:comparison}
+\paragraph{Compiler internals}
+Dottydoc relies on low-level and complex code which makes it very hard to maintain or add features where Tastydoc relies on the comprehensive Reflect API while trying to be as clear and as maintainable as possible. It implies that Tastydoc can be completely moved apart from the compiler and can be distributed as a separate tool.
+
+\paragraph{Output}
+Dottydoc outputs HTML/CSS which is not ideal for manual edit and it forces the user to host it on a website where Markdown can simply be viewed on an online git repository without further tasks. Tastydoc counters this problem by outputting Markdown. Also, Markdown can easily be converted to another format.
+
+\section{Extra features from Tastydoc}
+\label{sec:extra}
+\paragraph{Scope modifiers}
+Dottydoc does not handle scope modifiers (such as \texttt{private[this]}) whereas Tastydoc does.
+
+\paragraph{Known subclasses}
+Tastydoc keeps track of all seen subclasses of a class and links to their documentation files.
+
+\paragraph{Refined types}
+Tastydoc handles refined types where Dottydoc only remembers the parent of the type.
+
+\section{Bugs in Dottydoc that Tastydoc fixes}
+Dottydoc is not really maintained and hence does not follow the evolution in Master. Some bugs are present in Dottydoc. Tastydoc fixes them all.
+
+\paragraph{Weird output}
+It does not take care of colors in the \texttt{show} method and it results in faulty type or method output like\footnote{\url{https://dotty.epfl.ch/api/dotty/runtime/LazyVals$.html}}:
+\begin{lstlisting}[language=scala]
+ final val BITS_PER_LAZY_VAL : [31m2L[0m
+\end{lstlisting}
+
+\paragraph{Wrong parents}
+Classes often show to be extending Object instead of their superclass because Object is given first when asking for the parents list to the compiler, example\footnote{\url{https://dotty.epfl.ch/api/scala/Conversion.html}}:
+\begin{lstlisting}[language=scala]
+ abstract class Conversion [ -T, +U ]
+ extends Object with Function1
+\end{lstlisting}
+
+\paragraph{Annotations}
+Annotations which should not be displayed (like \texttt{@child}) are displayed and sometimes many times\footnote{\url{http://dotty.epfl.ch/api/scala/quoted/Expr.html}}.
+
+\paragraph{Compiler artifacts}
+The compiler produces artifacts which should be removed when producing documentation files. For example, default values produce artifacts and Dottydoc does not remove them\footnote{\url{https://dotty.epfl.ch/api/scala/tasty/reflect/Kernel.html}}:
+\begin{lstlisting}[language=scala]
+ def Definitions_FunctionClass$default$2 : Boolean
+\end{lstlisting}
+
+\paragraph{Potentially program breaking code}
+In Dottydoc one can find pieces of code that may break the program if used, such as\footnote{dotty/tools/dottydoc/model/entities.scala}:
+\begin{lstlisting}[language=scala]
+ def parents: List[Entity] = this :: this.parents
+\end{lstlisting}
+This is obviously an infinite recursion. Fortunately this method is never used.
+
+\chapter{Problems}
+\label{sec:problems}
+A few problems were encountered during the tools' development, some could not be fixed for reasons detailed below.
+
+\paragraph{Markdown escaping}
+We need a library to create a Markdown AST and render it to text because the output is written in Markdown. The library also needs to escape the input. For instance, a method named "\#", will be interpreted as a header of level 1 if it is not escaped which is not the expected behaviour. This creates a problem because no such library exists in Java or Scala and taking care of Markdown escaping would be time-consuming and was not the main topic of this project.
+
+\paragraph{Linking inside code blocks}
+We use code blocks indicating we have a piece of code so that a signature is formatted and syntax highlighted. In these code blocks, we also want to be able to make links pointing to the documentation page of a type. Unfortunately, Markdown fenced code blocks do not allow to have links in them. To counter this problem, we use HTML pre and code tag which are also understood by Markdown viewer. However, that causes two problems. First, it is not pure Markdown. Second, we lose the language syntax highlight from Markdown fenced code blocks.
+
+\paragraph{Section}
+Markdown does not have "division" with classes like the \texttt{} tag in HTML which could be useful to better structure the page into sections. This is, however, the philosophy of Markdown and is hence an expected feature.
+
+\paragraph{IDs for linking}
+If a single entity contains a type and a method definition with the same name (overloaded methods suffer from the same problem), the links we generate do not always point to the correct definition because it links to the first one appearing on the page. This is because most Markdown viewers do not understand user-specified id which could be useful for linking to specific things on the same page. Hence we do not use custom ids for linking in this project and only use automatically generated ids from headers.
+
+To mitigate this problem, we first output types and then values so that when linking it links to the first one appearing in the page which would be a type and it is what we want in most cases. However, this does not solve the problem of linking to type parameters and of linking to overloaded methods.
+
+\paragraph{Bug when calling owner}
+At the time of writing the documentation tool displays methods inherited from Object or Any and not overridden (which is not the desired behaviour) because a bug in Dotty makes the program crash when calling \texttt{owner} from a symbol.
+
+\chapter{Further work}
+Although the project is nearly complete, some work needs to be done to perfect the tool.
+
+\paragraph{Markdown escaping}
+As seen in \autoref{sec:problems} we do not escape anything before outputting Markdown, this is a problem that needs to be addressed by making a library capable of making a Markdown AST and rendering it to text while escaping the input. This is not a trivial task as Markdown has a lot of different available syntaxes. Especially when we extend Markdown with features such as tables.
+
+\paragraph{Type Lambdas}
+Type Lambdas are complex types to handle and convert to References, right now they are converted to constant References. This is not the expected behaviour: the output is not the one we expect and no linking can be done this way. It is, however, acceptable for a first version as type lambdas do not appear that often.
+
+\paragraph{Complex types}
+Assume the following code:
+\begin{lstlisting}[language=scala]
+ class Graph {
+ type Node = Int
+ }
+ def linkingGraph(g: Graph): g.Node = ???
+\end{lstlisting}
+Right now the type will only be referenced as \texttt{Node} instead of \texttt{g.Node}.
+
+\paragraph{Default values}
+Right now, the tool does not have knowledge of default values for parameters such as \texttt{def(x: Int = 0)} because the way TASTy files keep track of them is complex and not easily accessible.
+
+\paragraph{User-documentation parsing}
+User-documentation parsing lacks two features. First, supporting \texttt{@usecase} so that a signature is displayed in the form described in the use case instead of the one in the source code. Second, supporting defined pieces of documentation with \texttt{@define name ...} and then referencing them with \texttt{\$name}\footnote{Example in \url{https://github.com/scala/scala/blob/v2.12.2/src/library/scala/collection/immutable/List.scala\#L73}}.
+
+\paragraph{HTML/CSS}
+Markdown files for documentation are good for all the reasons mentioned in this report. However, some people still want a good HTML/CSS documentation. The aim would be to either take back what Dottydoc has and use it with our code or build something new. The first case would be pretty straightforward as our intermediate representation looks very similar to Dottydoc. The biggest modification would be made to the References as links are handled a bit differently in this tool.
+
+\end{document}
\ No newline at end of file
diff --git a/tastydoc/src/dotty/tastydoc/DocPrinter.scala b/tastydoc/src/dotty/tastydoc/DocPrinter.scala
new file mode 100644
index 000000000000..7cd06105e362
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/DocPrinter.scala
@@ -0,0 +1,437 @@
+package dotty.tastydoc
+
+import representations._
+import references._
+import comment.Comment
+
+import scala.annotation.tailrec
+
+import java.io._
+
+class DocPrinter(mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation], userDocSyntax: String, packagesToLink: List[String]){
+
+ val packagesMap = mutablePackagesMap.toMap
+
+ private def htmlPreCode(content: String, language: String = ""): String = {
+ "
" + content + "
"
+ }
+
+ private def makeLink(label: String, link: String, hasOwnFile: Boolean, declarationPath: List[String]): String = {
+ val labelName = label.stripSuffix("$")
+
+ val packageFormLink = link.replaceFirst("/", "").replaceAll("/", ".")
+
+ if(packagesToLink.exists(packageFormLink.matches(_))){
+ @tailrec
+ def ascendPath(path: List[String], link: List[String]): String = path match {
+ case x::xs if link.nonEmpty && link.head == x => ascendPath(xs, link.tail)
+ case _ => (if(path.isEmpty) "." else path.map(_ => "..").mkString("/")) + (if(link.isEmpty) "" else link.mkString("/", "/", ""))
+ }
+
+ val relativeLink = {
+ if(link == ""){
+ if(hasOwnFile){
+ if(declarationPath.isEmpty){
+ "."
+ }else {
+ declarationPath.map(_ => "..").mkString("/")
+ }
+ }else{
+ ""
+ }
+ }else{
+ ascendPath(declarationPath, link.split("/").toList.tail)
+ }
+ }
+
+ if(hasOwnFile){
+ "
" + labelName + ""
+ } else if(relativeLink == "") {
+ labelName
+ } else if(relativeLink == "."){
+ "
" + labelName + ""
+ } else{
+ "
" + labelName + ""
+ }
+ }else{
+ labelName
+ }
+ }
+
+ private def formatReferences(reference: Reference, declarationPath: List[String]) : String = reference match {
+ case CompanionReference(label, link, kind) =>
+ makeLink(label, link, true, declarationPath)
+ case TypeReference(label, link, typeParams, hasOwnFile) =>
+ if(typeParams.isEmpty){
+ makeLink(label, link, hasOwnFile, declarationPath)
+ }else{
+ makeLink(label, link, hasOwnFile, declarationPath) + typeParams.map(formatReferences(_, declarationPath)).mkString("[", ", ", "]")
+ }
+ case OrTypeReference(left, right) =>
+ formatReferences(left, declarationPath) + " | " + formatReferences(right, declarationPath)
+ case AndTypeReference(left, right) =>
+ formatReferences(left, declarationPath) + " & " + formatReferences(right, declarationPath)
+ case FunctionReference(args, returnValue, isImplicit) =>
+ args.map(formatReferences(_, declarationPath)).mkString("(", ", ", ") => ") + formatReferences(returnValue, declarationPath)
+ case TupleReference(args) =>
+ args.map(formatReferences(_, declarationPath)).mkString("(", ", ", ")")
+ case BoundsReference(low, high) =>
+ formatReferences(low, declarationPath) + " <: " + formatReferences(high, declarationPath)
+ case ByNameReference(ref) =>
+ "=> " + formatReferences(ref, declarationPath)
+ case ConstantReference(label) => label
+ case NamedReference(name, ref, isRepeated) => name + ": " + formatReferences(ref, declarationPath) + (if(isRepeated) "*" else "")
+ case RefinedReference(parent, ls) =>
+ formatReferences(parent, declarationPath) +
+ ls.map((kind, name, tpe) => kind + " " + name + ": " + formatReferences(tpe, declarationPath)).mkString("{ ", "; ", " }")
+
+ case EmptyReference => ""
+ }
+
+ private def formatParamList(paramList: ParamList, declarationPath: List[String]) : String = paramList.list.map(x => formatReferences(x, declarationPath)).mkString(
+ "(" + (if(paramList.isImplicit) "implicit " else ""),
+ ", ",
+ ")"
+ )
+
+ private def formatModifiers(modifiers: List[String], privateWithin: Option[Reference], protectedWithin: Option[Reference], annotations: List[TypeReference], declarationPath: List[String]): String = {
+ val hasInlineAnnot = annotations.contains(TypeReference("forceInline", "/scala", Nil, true))
+ val filteredModifiers = modifiers.filter(x => x != "private" && x != "protected" && (!hasInlineAnnot || x != "inline"))
+
+ (privateWithin match {
+ case Some(r) => formatReferences(r, declarationPath).mkString("private[", "", "] ")
+ case None if modifiers.contains("private") => "private "
+ case None => ""
+ }) +
+ (protectedWithin match {
+ case Some(r) => formatReferences(r, declarationPath).mkString("private[", "", "] ")
+ case None if modifiers.contains("protected") => "protected "
+ case None => ""
+ }) +
+ (if(filteredModifiers.nonEmpty) filteredModifiers.mkString("", " ", " ") else "")
+ }
+
+ private def formatComments(comment: (Map[String, EmulatedPackageRepresentation], String) => Option[Comment]) : String = comment(packagesMap, userDocSyntax) match {
+ case Some(c) =>
+ def removeLineEnds(str: String): String = {
+ if(str.isEmpty){
+ str
+ }else{
+ str.last match {
+ case '\n' => removeLineEnds(str.stripLineEnd)
+ case _ => str + "\n\n"
+ }
+ }
+ }
+
+ removeLineEnds(c.body) +
+ (if(c.authors.nonEmpty) Md.bold(Md.italics("authors")) + " " + c.authors.mkString(", ") + "\n" else "") +
+ (if(c.see.nonEmpty) Md.bold(Md.italics("see")) + " " + c.see.mkString(", ") + "\n" else "") +
+ (if(c.result.isDefined) Md.bold(Md.italics("return")) + " " + c.result.get + "\n" else "") +
+ (if(c.throws.nonEmpty) c.throws.map((x, y) => Md.bold(Md.italics(x)) + " " + y).mkString("\n") else "") +
+ (if(c.valueParams.nonEmpty) c.valueParams.map((x, y) => Md.bold(Md.italics(x)) + " " + y).mkString("\n") + "\n" else "") +
+ (if(c.typeParams.nonEmpty) c.typeParams.map((x, y) => Md.bold(Md.italics(x)) + " " + y).mkString("\n") + "\n" else "") +
+ (if(c.version.isDefined) Md.bold(Md.italics("version")) + " " + c.version.get + "\n" else "") +
+ (if(c.since.isDefined) Md.bold(Md.italics("since")) + " " + c.since.get + "\n" else "") +
+ (if(c.todo.nonEmpty) Md.bold(Md.italics("TODO")) + " " + c.todo.mkString(", ") + "\n" else "") +
+ (if(c.deprecated.isDefined) Md.bold(Md.italics("deprecated")) + " " + c.deprecated.get + "\n" else "") +
+ (if(c.note.nonEmpty) Md.bold(Md.italics("Note")) + " " + c.note.mkString("\n") + "\n"else "") +
+ (if(c.example.nonEmpty) Md.bold(Md.italics("Example")) + " " + c.example.mkString("\n") + "\n" else "") +
+ (if(c.constructor.isDefined) Md.bold(Md.italics("Constructor")) + " " + c.constructor.get + "\n" else "") +
+ (if(c.group.isDefined) Md.bold(Md.italics("Group")) + " " + c.group.get + "\n" else "") +
+ (if(c.groupDesc.nonEmpty) c.groupDesc.map((x, y) => Md.bold(Md.italics(x)) + " " + y).mkString("\n") else "") +
+ (if(c.groupNames.nonEmpty) c.groupNames.map((x, y) => Md.bold(Md.italics(x)) + " " + y).mkString("\n") + "\n" else "") +
+ (if(c.groupPrio.nonEmpty) c.groupPrio.map((x, y) => Md.bold(Md.italics(x)) + " " + y).mkString("\n") + "\n" else "") +
+ (if(c.hideImplicitConversions.nonEmpty) Md.bold(Md.italics("Hide Implicit Conversions")) + " " + c.hideImplicitConversions.mkString(", ") + "\n" else "")
+ case None => ""
+ }
+
+ private def formatAnnotations(annotations: List[TypeReference], declarationPath: List[String]): String = {
+ val str = annotations.map("@" + formatReferences(_, declarationPath)).mkString(" ")
+ if(str.isEmpty) str else str + " "
+ }
+
+ private def formatSimplifiedClassRepresentation(representation: ClassRepresentation, declarationPath: List[String]): String = {
+ def formatSimplifiedSignature(): String = {
+ htmlPreCode(
+ formatAnnotations(representation.annotations, declarationPath) +
+ formatModifiers(representation.modifiers, representation.privateWithin, representation.protectedWithin, representation.annotations, declarationPath) +
+ representation.kind +
+ " " +
+ makeLink(representation.name, representation.path.mkString("/", "/", ""), true, declarationPath)
+ , "scala") +
+ "\n"
+ }
+
+ formatSimplifiedSignature() +
+ formatComments(representation.comments)
+ }
+
+ private def formatClassRepresentation(representation: ClassRepresentation, declarationPath: List[String]): String = {
+ def formatCompanion(): String = representation.companion match {
+ case Some(ref@CompanionReference(_, _, kind)) =>
+ Md.header2("Companion " +
+ kind +
+ " " +
+ formatReferences(ref, declarationPath)
+ ) +
+ "\n"
+ case _ => ""
+ }
+
+ def formatSignature(): String = {
+ htmlPreCode(formatModifiers(representation.modifiers, representation.privateWithin, representation.protectedWithin, representation.annotations, representation.path) +
+ representation.kind +
+ " " +
+ (if(representation.isObject) representation.name.stripSuffix("$") else representation.name) +
+ (if(representation.typeParams.nonEmpty) representation.typeParams.mkString("[", ", ", "]") else "") +
+ (if(representation.parents.nonEmpty) " extends " + formatReferences(representation.parents.head, representation.path) + representation.parents.tail.map(" with " + formatReferences(_, representation.path)).mkString("") else "")
+ , "scala") +
+ "\n"
+ }
+
+ def formatClassAnnotations(): String = {
+ if(representation.annotations.isEmpty){
+ ""
+ }else{
+ Md.header2("Annotations:") +
+ formatAnnotations(representation.annotations, declarationPath) +
+ "\n"
+ }
+ }
+
+ def formatKnownSubclasses(): String = {
+ if(representation.knownSubclasses.isEmpty){
+ ""
+ }else{
+ Md.header2("Known subclasses:") +
+ representation.knownSubclasses.map(formatReferences(_, declarationPath)).mkString(", ") +
+ "\n"
+ }
+ }
+
+ def formatConstructors(): String = {
+ if(representation.constructors.isEmpty || representation.isObject || (representation.constructors.size == 1 && representation.constructors.head.paramLists.size == 1 && representation.constructors.head.paramLists.head.list == Nil)){
+ ""
+ }else{
+ Md.header2("Constructors:") +
+ representation.constructors.map(ls => htmlPreCode(representation.name + ls.paramLists.map(formatParamList(_, representation.path)).mkString(""), "scala") + "\n" + formatComments(ls.comments)).mkString("") +
+ "\n"
+ }
+ }
+
+ def formatMembers(): String = {
+
+ val nonPrivateMembers = representation.members.filter(!_.isPrivate)
+
+ val typeMembers = nonPrivateMembers.flatMap {
+ case r: TypeRepresentation => Some(r)
+ case _ => None
+ }
+ val objectMembers = nonPrivateMembers.flatMap {
+ case r: ClassRepresentation if r.isObject => Some(r)
+ case _ => None
+ }
+ val classMembers = nonPrivateMembers.flatMap {
+ case r: ClassRepresentation if !r.isObject && !r.isTrait => Some(r)
+ case _ => None
+ }
+ val traitMembers = nonPrivateMembers.flatMap {
+ case r: ClassRepresentation if r.isTrait => Some(r)
+ case _ => None
+ }
+ val defMembers = nonPrivateMembers.flatMap {
+ case r: DefRepresentation => Some(r)
+ case _ => None
+ }
+ val valMembers = nonPrivateMembers.flatMap {
+ case r: ValRepresentation => Some(r)
+ case _ => None
+ }
+
+ val abstractTypeMembers =
+ typeMembers.filter(_.isAbstract).map(x => Md.header3(x.name) + formatRepresentationToMarkdown(x, declarationPath)).mkString("") +
+ objectMembers.filter(_.isAbstract).map{x =>
+ traverseRepresentation(x)
+
+ Md.header3(x.name.stripSuffix("$")) +
+ formatSimplifiedClassRepresentation(x, declarationPath)
+ }.mkString("") +
+ classMembers.filter(_.isAbstract).map{x =>
+ traverseRepresentation(x)
+
+ Md.header3(x.name) +
+ formatSimplifiedClassRepresentation(x, declarationPath)
+ }.mkString("") +
+ traitMembers.filter(_.isAbstract).map{x =>
+ traverseRepresentation(x)
+
+ Md.header3(x.name) +
+ formatSimplifiedClassRepresentation(x, declarationPath)
+ }.mkString("")
+
+ val concreteTypeMembers =
+ typeMembers.filter(!_.isAbstract).map(x => Md.header3(x.name) + formatRepresentationToMarkdown(x, declarationPath)).mkString("") +
+ objectMembers.filter(!_.isAbstract).map{x =>
+ traverseRepresentation(x)
+
+ Md.header3(x.name.stripSuffix("$")) +
+ formatSimplifiedClassRepresentation(x, declarationPath)
+ }.mkString("") +
+ classMembers.filter(!_.isAbstract).map{x =>
+ traverseRepresentation(x)
+
+ Md.header3(x.name) +
+ formatSimplifiedClassRepresentation(x, declarationPath)
+ }.mkString("") +
+ traitMembers.filter(!_.isAbstract).map{x =>
+ traverseRepresentation(x)
+
+ Md.header3(x.name) +
+ formatSimplifiedClassRepresentation(x, declarationPath)
+ }.mkString("")
+
+ val abstractValueMembers =
+ defMembers.filter(_.isAbstract).map(x => Md.header3(x.name) + formatRepresentationToMarkdown(x, declarationPath)).mkString("") +
+ valMembers.filter(_.isAbstract).map(x => Md.header3(x.name) + formatRepresentationToMarkdown(x, declarationPath)).mkString("")
+ val concreteValueMembers =
+ defMembers.filter(!_.isAbstract).map(x => Md.header3(x.name) + formatRepresentationToMarkdown(x, declarationPath)).mkString("") +
+ valMembers.filter(!_.isAbstract).map(x => Md.header3(x.name) + formatRepresentationToMarkdown(x, declarationPath)).mkString("")
+
+ (if(abstractTypeMembers.nonEmpty){
+ Md.header2("Abstract Type Members:") +
+ abstractTypeMembers
+ }else{
+ ""
+ }) +
+ (if(concreteTypeMembers.nonEmpty){
+ Md.header2("Concrete Type Members:") +
+ concreteTypeMembers
+ }else{
+ ""
+ }) +
+ (if(abstractValueMembers.nonEmpty){
+ Md.header2("Abstract Value Members:") +
+ abstractValueMembers
+ }else{
+ ""
+ }) +
+ (if(concreteValueMembers.nonEmpty){
+ Md.header2("Concrete Value Members:") +
+ concreteValueMembers
+ }else{
+ ""
+ })
+ }
+
+ representation.path.mkString(".") +
+ "\n" +
+ Md.header1(representation.kind + " " + (if(representation.isObject) representation.name.stripSuffix("$") else representation.name)) +
+ "\n" +
+ formatCompanion() +
+ formatSignature() +
+ formatComments(representation.comments) +
+ formatClassAnnotations() +
+ formatKnownSubclasses() +
+ formatConstructors() +
+ formatMembers()
+ }
+
+ private def formatDefRepresentation(representation: DefRepresentation, declarationPath: List[String]): String = {
+ htmlPreCode(
+ formatAnnotations(representation.annotations, declarationPath) +
+ formatModifiers(representation.modifiers, representation.privateWithin, representation.protectedWithin, representation.annotations, declarationPath) +
+ "def " +
+ representation.name +
+ (if(representation.typeParams.nonEmpty) representation.typeParams.mkString("[", ", ", "]") else "") +
+ representation.paramLists.map(formatParamList(_, declarationPath)).mkString("") +
+ ": " +
+ formatReferences(representation.returnValue, declarationPath)
+ , "scala") +
+ "\n" +
+ {
+ val com = formatComments(representation.comments)
+ if(com == "") "\n" else com
+ }
+ }
+
+ private def formatValRepresentation(representation: ValRepresentation, declarationPath: List[String]): String = {
+ htmlPreCode(
+ formatAnnotations(representation.annotations, declarationPath) +
+ formatModifiers(representation.modifiers, representation.privateWithin, representation.protectedWithin, representation.annotations, declarationPath) +
+ (if(representation.isVar) "var " else "val ") +
+ representation.name +
+ ": " +
+ formatReferences(representation.returnValue, declarationPath)
+ , "scala") +
+ "\n" +
+ formatComments(representation.comments) +
+ "\n"
+ }
+
+ private def formatTypeRepresentation(representation: TypeRepresentation, declarationPath: List[String]): String = {
+ htmlPreCode(
+ formatAnnotations(representation.annotations, declarationPath) +
+ formatModifiers(representation.modifiers, representation.privateWithin, representation.protectedWithin, representation.annotations, declarationPath) +
+ "type " +
+ representation.name +
+ (if(representation.isAbstract) "" else ": " + formatReferences(representation.alias.get, declarationPath))
+ , "scala") +
+ "\n" +
+ formatComments(representation.comments) +
+ "\n"
+ }
+
+ def formatRepresentationToMarkdown(representation: Representation, declarationPath: List[String], useSimplifiedFormat: Boolean = false): String = representation match {
+ case r: EmulatedPackageRepresentation =>
+ if(useSimplifiedFormat){
+ htmlPreCode("package " + makeLink(r.name, (r.path :+ r.name).mkString("/", "/", ""), true, declarationPath), "scala") //Package file are at one level below the current package
+ }else{
+ Md.header1("Package " + r.name) +
+ Md.header2("Members:") +
+ r.members.foldLeft("")((acc, m) => acc + formatRepresentationToMarkdown(m, declarationPath, true))
+ }
+
+ case r : PackageRepresentation =>
+ htmlPreCode("package " + makeLink(r.name, (r.path :+ r.name).mkString("/", "/", ""), true, declarationPath), "scala") //Package file are at one level below the current package
+
+ case r: ImportRepresentation => ""
+
+ case r: ClassRepresentation =>
+ if(useSimplifiedFormat){
+ formatSimplifiedClassRepresentation(r, declarationPath)
+ }else{
+ formatClassRepresentation(r, declarationPath)
+ }
+
+ case r: DefRepresentation => formatDefRepresentation(r, declarationPath)
+
+ case r: ValRepresentation => formatValRepresentation(r, declarationPath)
+
+ case r: TypeRepresentation => formatTypeRepresentation(r, declarationPath)
+ }
+
+ val folderPrefix = "tastydoc/documentation/"
+ /** Traversing a Representation recursively producing markdown files along the way. In principle, this should be the only method called from outside of the class. */
+ def traverseRepresentation(representation: Representation): Unit = representation match {
+ case r: EmulatedPackageRepresentation =>
+ r.members.foreach(traverseRepresentation)
+ val file = new File("./" + folderPrefix + (r.path :+ r.name).mkString("/", "/", "/") + r.name + ".md")
+ file.getParentFile.mkdirs
+ val pw = new PrintWriter(file)
+ pw.write(formatRepresentationToMarkdown(r, (r.path :+ r.name)))
+ pw.close
+
+ case r: PackageRepresentation =>
+ r.members.foreach(traverseRepresentation)
+
+ case r: ClassRepresentation =>
+ val file = new File("./" + folderPrefix + r.path.mkString("", "/", "/") + r.name + ".md")
+ file.getParentFile.mkdirs
+ val pw = new PrintWriter(file)
+ pw.write(formatRepresentationToMarkdown(r, r.path))
+ pw.close
+
+ case _ =>
+ }
+}
\ No newline at end of file
diff --git a/tastydoc/src/dotty/tastydoc/Main.scala b/tastydoc/src/dotty/tastydoc/Main.scala
new file mode 100644
index 000000000000..01af8156975c
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/Main.scala
@@ -0,0 +1,105 @@
+package dotty.tastydoc
+
+import scala.tasty.file._
+
+import dotty.tastydoc.representations._
+
+import java.io._
+
+object Main {
+
+ /** Call main with the following arguments to produce Markdown documentation files:
+ * * **[--syntax SYNTAX]** Syntax for parsing user documentation (either *wiki or markdown*)
+ * * **[--packagestolink REGEXES...]** Regexes of packages or entities (example: `scala.collection.*`). Only the types with a path matching these regexes will produce links in the documentation files
+ * * **[--classpath URI]** Extra classpath for input files
+ * * **[-i FILES...]** TASTy files
+ * * **[-d DIRECTORIES...]** Directories to recursively find TASTy files
+ */
+ def main(args: Array[String]): Unit = {
+ val userDocSyntax = {
+ val idx = args.indexOf("--syntax")
+ if(idx >= 0 && args.size > idx + 1){
+ if(args(idx + 1) == "markdown"){
+ "markdown"
+ }else if(args(idx + 1) == "wiki"){
+ "wiki"
+ }else{
+ println("Wrong parameter for -syntax. Using default: wiki")
+ "wiki"
+ }
+ }else{
+ "wiki"
+ }
+ }
+
+ val packagesToLink = {
+ val idx = args.indexOf("--packagestolink")
+ if(idx >= 0 && args.size > idx + 1){
+ args.drop(idx + 1).takeWhile(! _.startsWith("-")).toList
+ }else{
+ Nil
+ }
+ }
+
+
+ val extraClasspath = {
+ val idx = args.indexOf("--classpath")
+ if(idx >= 0 && args.size > idx + 1){
+ args(idx + 1)
+ }else{
+ "."
+ }
+ }
+
+ val classesI = {
+ val idx = args.indexOf("-i")
+ if(idx >= 0 && args.size > idx + 1){
+ args.drop(idx + 1).takeWhile(_!= "-d").toList
+ }else{
+ Nil
+ }
+ }
+
+ val classesD = {
+ val idx = args.indexOf("-d")
+ if(idx >= 0 && args.size > idx + 1){
+ val dirs = args.drop(idx + 1).takeWhile(_!= "-i").toList
+
+ def findTastyFiles(f: File): Array[String] = {
+ val allFiles = f.listFiles
+ val tastyFiles = allFiles.filter(f => f.getName.endsWith(".tasty")).map(x => x.getPath.stripPrefix(extraClasspath + "/").stripSuffix(".tasty").replaceAll("\\/", "."))
+ tastyFiles ++ allFiles.filter(_.isDirectory).flatMap(findTastyFiles)
+ }
+
+ dirs.flatMap{d =>
+ val f = new File(extraClasspath + "/" + d)
+ if(f.exists){
+ findTastyFiles(f)
+ }else{
+ println("[warn] Ignoring invalid directory name: " + d)
+ Nil
+ }
+ }
+ }else{
+ Nil
+ }
+ }
+
+ val classes = classesI ++ classesD
+
+ if (classes.isEmpty) {
+ println("Dotty Tastydoc: No classes were passed as argument")
+ } else {
+ println("Running Dotty Tastydoc on: " + classes.mkString(" "))
+ val mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation] = new scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]()
+ val tc = new TastydocConsumer(mutablePackagesMap)
+ ConsumeTasty(extraClasspath, classes, tc)
+
+ representations.setSubClasses(mutablePackagesMap)
+
+ val docPrinter = new DocPrinter(mutablePackagesMap, userDocSyntax, packagesToLink)
+
+ mutablePackagesMap.foreach((_, v) => docPrinter.traverseRepresentation(v))
+ }
+ }
+}
diff --git a/tastydoc/src/dotty/tastydoc/TastyExtractor.scala b/tastydoc/src/dotty/tastydoc/TastyExtractor.scala
new file mode 100644
index 000000000000..7b348f46fa54
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/TastyExtractor.scala
@@ -0,0 +1,179 @@
+package dotty.tastydoc
+
+import scala.tasty.Reflection
+import dotty.tastydoc.comment.{CommentParser, CommentCleaner, Comment, WikiComment, MarkdownComment}
+import dotty.tastydoc.references._
+import dotty.tastydoc.representations._
+
+/** A trait containing useful methods for extracting information from the reflect API */
+trait TastyExtractor extends TastyTypeConverter with CommentParser with CommentCleaner{
+ def extractPath(reflect: Reflection)(symbol: reflect.Symbol) : List[String] = {
+ import reflect._
+
+ val pathArray = symbol.show(implicitly[reflect.Context].withoutColors).split("\\.")
+ pathArray.view(0, pathArray.length - 1).toList
+ }
+
+ def extractModifiers(reflect: Reflection)(flags: reflect.Flags, privateWithin: Option[reflect.Type], protectedWithin: Option[reflect.Type]) : (List[String], Option[Reference], Option[Reference]) = {
+ import reflect._
+
+ (((if(flags.is(Flags.Override)) "override" else "") ::
+ (if(flags.is(Flags.Private)) "private" else "")::
+ (if(flags.is(Flags.Protected)) "protected" else "") ::
+ (if(flags.is(Flags.Final)) "final" else "") ::
+ (if(flags.is(Flags.Sealed)) "sealed" else "") ::
+ (if(flags.is(Flags.Implicit)) "implicit" else "") ::
+ (if(flags.is(Flags.Abstract)) "abstract" else "") ::
+ // (if(flags.is(Flags.AbsOverride)) "absOverride" else "") :: //TOFIX Not visible, fix in Dotty. When fixed, need fix in output as well
+ // (if(flags.is(Flags.Deferred)) "deferred" else "") :: //TOFIX Not visible, fix in Dotty. When fixed, need fix in output as well
+ (if(flags.is(Flags.Inline)) "inline" else "") ::
+ Nil) filter (_ != ""),
+
+ privateWithin match {
+ case Some(t) => Some(convertTypeToReference(reflect)(t))
+ case None => None
+ },
+ protectedWithin match {
+ case Some(t) => Some(convertTypeToReference(reflect)(t))
+ case None => None
+ })
+ }
+
+ def extractComments(reflect: Reflection)(comment: Option[reflect.Comment], rep: Representation) : (Map[String, EmulatedPackageRepresentation], String) => Option[Comment] = {
+ import reflect._
+
+ comment match {
+ case Some(com) =>
+ (packages, userDocSyntax) => {
+ val parsed = parse(rep, packages, clean(com.raw), com.raw)
+ if (userDocSyntax == "markdown") {
+ Some(MarkdownComment(rep, parsed, packages).comment)
+ }else if(userDocSyntax == "wiki"){
+ Some(WikiComment(rep, parsed, packages).comment)
+ }else{
+ Some(WikiComment(rep, parsed, packages).comment)
+ }
+ }
+ case None => (_, _) => None
+ }
+ }
+
+ def extractClassMembers(reflect: Reflection)(body: List[reflect.Statement], symbol: reflect.ClassDefSymbol, parentRepresentation: Some[Representation]) given (mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]) : List[Representation with Modifiers] = {
+ import reflect._
+
+ /** Filter fields which shouldn't be displayed in the doc
+ */
+ def filterSymbol(symbol: reflect.Symbol): Boolean = {
+ val ownerPath = extractPath(reflect)(symbol.owner)
+
+ !symbol.flags.is(Flags.Synthetic) &&
+ !symbol.flags.is(Flags.Artifact) &&
+ !symbol.flags.is(Flags.StableRealizable) && //Remove val generated for object definitions inside classes
+ !symbol.name.contains("$default$") &&//Remove artifact methods generated for methods with default parameters
+ !(symbol.owner.name == "Object" && ownerPath == List("java", "lang")) &&
+ !(symbol.owner.name == "Any" && ownerPath == List("scala"))
+ }
+
+ (body.flatMap{
+ case IsDefDef(_) => None //No definitions, they are appended with symbol.methods below
+ case IsValDef(_) => None //No val/var, they are appended with symbol.fields below
+ case IsInlined(_) => None //Inlined aren't desirable members
+ case x => Some(x)
+ }.filter(x => filterSymbol(x.symbol)).map(convertToRepresentation(reflect)(_, parentRepresentation)) ++
+ symbol.methods.filter(x => filterSymbol(x)).map{x => convertToRepresentation(reflect)(x.tree, parentRepresentation)} ++
+ symbol.fields.filter(x => filterSymbol(x)).flatMap{case reflect.IsValDefSymbol(x) => Some(x) case _ => None}.map{x => convertToRepresentation(reflect)(x.tree, parentRepresentation)}
+ )
+ .flatMap{
+ case r: Representation with Modifiers => Some(r)
+ case _ => None
+ }
+ .sortBy(_.name)
+ }
+
+ def extractParents(reflect: Reflection)(parents: List[reflect.Tree]): List[Reference] = {
+ import reflect._
+
+ val parentsReferences = parents.map{
+ case reflect.IsTypeTree(c) => convertTypeToReference(reflect)(c.tpe)
+ case reflect.IsTerm(c) => convertTypeToReference(reflect)(c.tpe)
+ case _ => throw Exception("Unhandeld case in parents. Please open an issue.")
+ }
+
+ parentsReferences.filter{_ match{
+ case TypeReference("Object", "/lang", _, _) | TypeReference("Object", "/java/lang", _, _) => false
+ case _ => true
+ }}
+ }
+
+ /** The kind of a ClassDef can be one of the following: class, case class, object, case object, trait
+ *
+ * @return (is case, is a trait, is an object, the kind as a String)
+ */
+ def extractKind(reflect: Reflection)(flags: reflect.Flags): (Boolean, Boolean, Boolean, String) = {
+ import reflect._
+
+ val isCase = flags.is(reflect.Flags.Case)
+ val isTrait = flags.is(reflect.Flags.Trait)
+ val isObject = flags.is(reflect.Flags.Object)
+ val kind = {
+ if(isTrait){
+ "trait"
+ }else{
+ (if(isCase){
+ "case "
+ }else{
+ ""
+ }) +
+ (if(isObject){
+ "object"
+ }else{
+ "class"
+ })
+ }
+ }
+ (isCase, isTrait, isObject, kind)
+ }
+
+ def extractCompanion(reflect: Reflection)(companionModule: Option[reflect.ValDefSymbol], companionClass: Option[reflect.ClassDefSymbol], companionIsObject: Boolean): Option[CompanionReference] = {
+ import reflect._
+
+ if(companionIsObject){
+ companionModule match {
+ case Some(c) =>
+ val path = extractPath(reflect)(c)
+ val (_, _, _, kind) = extractKind(reflect)(c.flags)
+ Some(CompanionReference(c.name + "$", path.mkString("/", "/", ""), kind))
+ case None => None
+ }
+ }else{
+ companionClass match {
+ case Some(c) =>
+ val path = extractPath(reflect)(c)
+ val (_, _, _, kind) = extractKind(reflect)(c.flags)
+ Some(CompanionReference(c.name, path.mkString("/", "/", ""), kind))
+ case None => None
+ }
+ }
+ }
+
+ def extractAnnotations(reflect: Reflection)(annots: List[reflect.Term]): List[TypeReference] = {
+ import reflect._
+
+ def keepAnnot(label: String, link: String): Boolean = {
+ !(label == "SourceFile" && link == "/internal") &&
+ !(label == "Child" && link == "/internal")
+ }
+
+ annots.flatMap{a =>
+ convertTypeToReference(reflect)(a.tpe) match {
+ case ref@TypeReference(label, link, _, _) if keepAnnot(label, link) => Some(ref)
+ case _ => None
+ }
+ }
+ }
+
+ def extractPackageNameAndPath(pidShowNoColor: String): (String, List[String]) = {
+ val pidSplit = pidShowNoColor.split("\\.")
+ (pidSplit.last, pidSplit.init.toList)
+ }
+}
\ No newline at end of file
diff --git a/tastydoc/src/dotty/tastydoc/TastyTypeConverter.scala b/tastydoc/src/dotty/tastydoc/TastyTypeConverter.scala
new file mode 100644
index 000000000000..b3600840e021
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/TastyTypeConverter.scala
@@ -0,0 +1,107 @@
+package dotty.tastydoc
+
+import scala.tasty.Reflection
+import dotty.tastydoc.references._
+
+/** Trait containing methods for converting from Reflect types to References */
+trait TastyTypeConverter {
+
+ def convertTypeOrBoundsToReference(reflect: Reflection)(typeOrBounds: reflect.TypeOrBounds): Reference = {
+ import reflect._
+
+ def anyOrNothing(reference: Reference): Boolean = reference match {
+ case TypeReference("Any", "/scala", _, _) => true
+ case TypeReference("Nothing", "/scala", _, _) => true
+ case _ => false
+ }
+
+ typeOrBounds match {
+ case reflect.IsType(tpe) => convertTypeToReference(reflect)(tpe)
+ case reflect.IsTypeBounds(reflect.TypeBounds(low, hi)) =>
+ val lowRef = convertTypeToReference(reflect)(low)
+ val hiRef = convertTypeToReference(reflect)(hi)
+ if(hiRef == lowRef){
+ hiRef
+ }else{
+ BoundsReference(lowRef, hiRef)
+ }
+ case reflect.NoPrefix() => EmptyReference
+ }
+ }
+
+ def convertTypeToReference(reflect: Reflection)(tp: reflect.Type): Reference = {
+ import reflect._
+
+ //Inner method to avoid passing the reflection each time
+ def inner(tp: reflect.Type): Reference = tp match {
+ case reflect.Type.IsOrType(reflect.Type.OrType(left, right)) => OrTypeReference(inner(left), inner(right))
+ case reflect.Type.IsAndType(reflect.Type.AndType(left, right)) => AndTypeReference(inner(left), inner(right))
+ case reflect.Type.IsByNameType(reflect.Type.ByNameType(tpe)) => ByNameReference(inner(tpe))
+ case reflect.Type.IsConstantType(reflect.Type.ConstantType(constant)) => ConstantReference(constant.value.toString)
+ case reflect.Type.IsThisType(reflect.Type.ThisType(tpe)) => inner(tpe)
+ case reflect.Type.IsAnnotatedType(reflect.Type.AnnotatedType(tpe, _)) => inner(tpe)
+ case reflect.Type.IsTypeLambda(reflect.Type.TypeLambda(paramNames, paramTypes, resType)) => ConstantReference(tp.show(implicitly[reflect.Context].withoutColors)) //TOFIX
+ case reflect.Type.IsRefinement(reflect.Type.Refinement(parent, name, info)) =>
+ val tuple = convertTypeOrBoundsToReference(reflect)(info) match {
+ case r if (info match {case reflect.IsTypeBounds(info) => true case _ => false}) => ("type", name, r)
+ case r@TypeReference(_, _, _, _) => ("val", name, r)
+ case ByNameReference(rChild) => ("def", name, rChild)
+ case r => throw new Exception("Match error in info of Refinement. This should not happend, please open an issue. " + r)
+ }
+ convertTypeToReference(reflect)(parent) match {
+ case RefinedReference(p, ls) =>
+ RefinedReference(p, ls:+tuple)
+ case t => RefinedReference(t, List(tuple))
+ }
+ case reflect.Type.IsAppliedType(reflect.Type.AppliedType(tpe, typeOrBoundsList)) =>
+ inner(tpe) match {
+ case TypeReference(label, link, _, hasOwnFile) =>
+ if(link == "/scala"){
+ if(label.matches("Function[1-9]") || label.matches("Function[1-9][0-9]")){
+ val argsAndReturn = typeOrBoundsList.map(convertTypeOrBoundsToReference(reflect)(_))
+ FunctionReference(argsAndReturn.take(argsAndReturn.size - 1), argsAndReturn.last, false)
+ }else if(label.matches("Tuple[1-9]") || label.matches("Tuple[1-9][0-9]")){
+ TupleReference(typeOrBoundsList.map(convertTypeOrBoundsToReference(reflect)(_)))
+ }else{
+ TypeReference(label, link, typeOrBoundsList.map(convertTypeOrBoundsToReference(reflect)(_)), hasOwnFile)
+ }
+ }else{
+ TypeReference(label, link, typeOrBoundsList.map(convertTypeOrBoundsToReference(reflect)(_)), hasOwnFile)
+ }
+ case _ => throw Exception("Match error in AppliedType. This should not happen, please open an issue. " + tp)
+ }
+ case reflect.Type.IsTypeRef(reflect.Type.TypeRef(typeName, qual)) =>
+ convertTypeOrBoundsToReference(reflect)(qual) match {
+ case TypeReference(label, link, xs, _) => TypeReference(typeName, link + "/" + label, xs, true)
+ case EmptyReference => TypeReference(typeName, "", Nil, true)
+ case _ => throw Exception("Match error in TypeRef. This should not happen, please open an issue. " + convertTypeOrBoundsToReference(reflect)(qual))
+ }
+ case reflect.Type.IsTermRef(reflect.Type.TermRef(typeName, qual)) =>
+ convertTypeOrBoundsToReference(reflect)(qual) match {
+ case TypeReference(label, link, xs, _) => TypeReference(typeName + "$", link + "/" + label, xs)
+ case EmptyReference => TypeReference(typeName, "", Nil)
+ case _ => throw Exception("Match error in TermRef. This should not happen, please open an issue. " + convertTypeOrBoundsToReference(reflect)(qual))
+ }
+ case reflect.Type.IsSymRef(reflect.Type.SymRef(symbol, typeOrBounds)) => symbol match {
+ case reflect.IsClassDefSymbol(_) => //Need to be split because these types have their own file
+ convertTypeOrBoundsToReference(reflect)(typeOrBounds) match {
+ case TypeReference(label, link, xs, _) => TypeReference(symbol.name, link + "/" + label, xs, true)
+ case EmptyReference if symbol.name == "
" | symbol.name == "_root_" => EmptyReference
+ case EmptyReference => TypeReference(symbol.name, "", Nil, true)
+ case _ => throw Exception("Match error in SymRef/TypeOrBounds/ClassDef. This should not happen, please open an issue. " + convertTypeOrBoundsToReference(reflect)(typeOrBounds))
+ }
+ case reflect.IsTermSymbol(_) | reflect.IsTypeDefSymbol(_) =>
+ convertTypeOrBoundsToReference(reflect)(typeOrBounds) match {
+ case TypeReference(label, link, xs, _) => TypeReference(symbol.name, link + "/" + label, xs)
+ case EmptyReference if symbol.name == "" | symbol.name == "_root_" => EmptyReference
+ case EmptyReference => TypeReference(symbol.name, "", Nil)
+ case _ => throw Exception("Match error in SymRef/TypeOrBounds/Other. This should not happen, please open an issue. " + convertTypeOrBoundsToReference(reflect)(typeOrBounds))
+ }
+ case _ => throw Exception("Match error in SymRef. This should not happen, please open an issue. " + symbol)
+ }
+ case _ => throw Exception("No match for type in conversion to Reference. This should not happen, please open an issue. " + tp)
+ }
+
+ inner(tp)
+ }
+}
diff --git a/tastydoc/src/dotty/tastydoc/TastydocConsumer.scala b/tastydoc/src/dotty/tastydoc/TastydocConsumer.scala
new file mode 100644
index 000000000000..9678a1014d64
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/TastydocConsumer.scala
@@ -0,0 +1,19 @@
+package dotty.tastydoc
+
+import scala.tasty.Reflection
+import scala.tasty.file.TastyConsumer
+
+import dotty.tastydoc.representations._
+
+/* Extends TastyConsumer and consumes Tasty Files to produce Representations
+ *
+ * @param mutablePackagesMap A mutable HashMap where seen packages are added
+ */
+class TastydocConsumer(mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]) extends TastyConsumer {
+
+ final def apply(reflect: Reflection)(root: reflect.Tree): Unit = {
+ import reflect._
+
+ representations.convertToRepresentation(reflect)(root, None) given (mutablePackagesMap)
+ }
+}
\ No newline at end of file
diff --git a/tastydoc/src/dotty/tastydoc/comment/BodyEntities.scala b/tastydoc/src/dotty/tastydoc/comment/BodyEntities.scala
new file mode 100644
index 000000000000..00a4722b7a49
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/comment/BodyEntities.scala
@@ -0,0 +1,94 @@
+package dotty.tastydoc
+package comment
+
+import scala.collection._
+import representations._
+
+/** A body of text. A comment has a single body, which is composed of
+ * at least one block. Inside every body is exactly one summary (see
+ * [[scala.tools.nsc.doc.model.comment.Summary]]). */
+final case class Body(blocks: Seq[Block]) {
+
+ /** The summary text of the comment body. */
+ lazy val summary: Option[Body] = {
+ def summaryInBlock(block: Block): Seq[Inline] = block match {
+ case Title(text, _) => summaryInInline(text)
+ case Paragraph(text) => summaryInInline(text)
+ case UnorderedList(items) => items flatMap summaryInBlock
+ case OrderedList(items, _) => items flatMap summaryInBlock
+ case DefinitionList(items) => items.values.toSeq flatMap summaryInBlock
+ case _ => Nil
+ }
+ def summaryInInline(text: Inline): Seq[Inline] = text match {
+ case Summary(text) => List(text)
+ case Chain(items) => items flatMap summaryInInline
+ case Italic(text) => summaryInInline(text)
+ case Bold(text) => summaryInInline(text)
+ case Underline(text) => summaryInInline(text)
+ case Superscript(text) => summaryInInline(text)
+ case Subscript(text) => summaryInInline(text)
+ case Link(_, title) => summaryInInline(title)
+ case _ => Nil
+ }
+ (blocks flatMap summaryInBlock).toList match {
+ case Nil => None
+ case inl :: Nil => Some(Body(Seq(Paragraph(inl))))
+ case inls => Some(Body(Seq(Paragraph(Chain(inls)))))
+ }
+ }
+}
+
+/** A block-level element of text, such as a paragraph or code block. */
+sealed abstract class Block
+
+final case class Title(text: Inline, level: Int) extends Block
+final case class Paragraph(text: Inline) extends Block
+final case class Code(data: String) extends Block
+final case class UnorderedList(items: Seq[Block]) extends Block
+final case class OrderedList(items: Seq[Block], style: String) extends Block
+final case class DefinitionList(items: SortedMap[Inline, Block]) extends Block
+final case class HorizontalRule() extends Block
+
+/** An section of text inside a block, possibly with formatting. */
+sealed abstract class Inline
+
+final case class Chain(items: Seq[Inline]) extends Inline
+final case class Italic(text: Inline) extends Inline
+final case class Bold(text: Inline) extends Inline
+final case class Underline(text: Inline) extends Inline
+final case class Superscript(text: Inline) extends Inline
+final case class Subscript(text: Inline) extends Inline
+final case class Link(target: String, title: Inline) extends Inline
+final case class Monospace(text: Inline) extends Inline
+final case class Text(text: String) extends Inline
+abstract class RepresentationLink(val title: Inline) extends Inline { def link: LinkTo }
+object RepresentationLink {
+ def apply(title: Inline, linkTo: LinkTo) = new RepresentationLink(title) { def link: LinkTo = linkTo }
+ def unapply(el: RepresentationLink): Some[(Inline, LinkTo)] = Some((el.title, el.link))
+}
+final case class HtmlTag(data: String) extends Inline {
+ private val Pattern = """(?ms)\A<(/?)(.*?)[\s>].*\z""".r
+ private val (isEnd, tagName) = data match {
+ case Pattern(s1, s2) =>
+ (! s1.isEmpty, Some(s2.toLowerCase))
+ case _ =>
+ (false, None)
+ }
+
+ def canClose(open: HtmlTag) = {
+ isEnd && tagName == open.tagName
+ }
+
+ private val TagsNotToClose = Set("br", "img")
+ def close = tagName collect { case name if !TagsNotToClose(name) => HtmlTag(s"") }
+}
+
+/** The summary of a comment, usually its first sentence. There must be exactly one summary per body. */
+final case class Summary(text: Inline) extends Inline
+
+sealed trait LinkTo
+final case class LinkToExternal(name: String, url: String) extends LinkTo
+final case class Tooltip(name: String) extends LinkTo
+
+/** Linking directly to entities is not picklable because of cyclic references */
+final case class LinkToRepresentation(representation: Representation) extends LinkTo
diff --git a/tastydoc/src/dotty/tastydoc/comment/Comment.scala b/tastydoc/src/dotty/tastydoc/comment/Comment.scala
new file mode 100644
index 000000000000..81aa7a92ef40
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/comment/Comment.scala
@@ -0,0 +1,167 @@
+package dotty.tastydoc
+package comment
+
+import com.vladsch.flexmark.util.ast.{ Node => MarkdownNode }
+import HtmlParsers._
+import util.MemberLookup
+import representations._
+
+import com.vladsch.flexmark.formatter.Formatter;
+import com.vladsch.flexmark.util.options.MutableDataSet;
+
+case class Comment (
+ body: String,
+ short: String,
+ authors: List[String],
+ see: List[String],
+ result: Option[String],
+ throws: Map[String, String],
+ valueParams: Map[String, String],
+ typeParams: Map[String, String],
+ version: Option[String],
+ since: Option[String],
+ todo: List[String],
+ deprecated: Option[String],
+ note: List[String],
+ example: List[String],
+ constructor: Option[String],
+ group: Option[String],
+ groupDesc: Map[String, String],
+ groupNames: Map[String, String],
+ groupPrio: Map[String, String],
+ /** List of conversions to hide - containing e.g: `scala.Predef.FloatArrayOps` */
+ hideImplicitConversions: List[String]
+)
+
+private[comment] case class ParsedComment (
+ body: String,
+ authors: List[String],
+ see: List[String],
+ result: List[String],
+ throws: Map[String, String],
+ valueParams: Map[String, String],
+ typeParams: Map[String, String],
+ version: List[String],
+ since: List[String],
+ todo: List[String],
+ deprecated: List[String],
+ note: List[String],
+ example: List[String],
+ constructor: List[String],
+ group: List[String],
+ groupDesc: Map[String, String],
+ groupNames: Map[String, String],
+ groupPrio: Map[String, String],
+ hideImplicitConversions: List[String],
+ shortDescription: List[String]
+)
+
+trait MarkupConversion[T](packages: Map[String, EmulatedPackageRepresentation]) extends MemberLookup {
+ def ent: Representation
+ def parsed: ParsedComment
+
+ protected def linkedExceptions(m: Map[String, String]): Map[String, String]
+ protected def stringToMarkup(str: String): T
+ protected def markupToMarkdown(t: T): String
+ protected def stringToShortMarkdown(str: String): String
+ protected def filterEmpty(xs: List[String]): List[T]
+ protected def filterEmpty(xs: Map[String, String]): Map[String, T]
+
+ private def single(annot: String, xs: List[String], filter: Boolean = true): Option[T] =
+ (if (filter) filterEmpty(xs) else xs.map(stringToMarkup)) match {
+ case x :: xs =>
+ Some(x)
+ case _ => None
+ }
+
+ final def comment: Comment = Comment(
+ body = markupToMarkdown(stringToMarkup(parsed.body)),
+ short = stringToShortMarkdown(parsed.body),
+ authors = filterEmpty(parsed.authors).map(markupToMarkdown),
+ see = filterEmpty(parsed.see).map(markupToMarkdown),
+ result = single("@result", parsed.result).map(markupToMarkdown),
+ throws = linkedExceptions(parsed.throws),
+ valueParams = filterEmpty(parsed.valueParams).mapValues(markupToMarkdown),
+ typeParams = filterEmpty(parsed.typeParams).mapValues(markupToMarkdown),
+ version = single("@version", parsed.version).map(markupToMarkdown),
+ since = single("@since", parsed.since).map(markupToMarkdown),
+ todo = filterEmpty(parsed.todo).map(markupToMarkdown),
+ deprecated = single("@deprecated", parsed.deprecated, filter = false).map(markupToMarkdown),
+ note = filterEmpty(parsed.note).map(markupToMarkdown),
+ example = filterEmpty(parsed.example).map(markupToMarkdown),
+ constructor = single("@constructor", parsed.constructor).map(markupToMarkdown),
+ group = single("@group", parsed.group).map(markupToMarkdown),
+ groupDesc = filterEmpty(parsed.groupDesc).mapValues(markupToMarkdown),
+ groupNames = filterEmpty(parsed.groupNames).mapValues(markupToMarkdown),
+ groupPrio = filterEmpty(parsed.groupPrio).mapValues(markupToMarkdown),
+ hideImplicitConversions = filterEmpty(parsed.hideImplicitConversions).map(markupToMarkdown)
+ )
+}
+
+case class MarkdownComment(ent: Representation, parsed: ParsedComment, packages: Map[String, EmulatedPackageRepresentation])
+extends MarkupConversion[MarkdownNode](packages) {
+
+ def stringToMarkup(str: String) =
+ str.toMarkdown(ent, packages)
+
+ def stringToShortMarkdown(str: String) =
+ str.toMarkdown(ent, packages).shortenAndShow
+
+ def markupToMarkdown(md: MarkdownNode) =
+ md.show
+
+ def linkedExceptions(m: Map[String, String]) = {
+ val inlineToMarkdown = InlineToMarkdown(ent)
+ m.map { case (targetStr, body) =>
+ val link = makeRepresentationLink(ent, packages, Monospace(Text(targetStr)), targetStr)
+ (targetStr, inlineToMarkdown(link))
+ }
+ }
+
+ def filterEmpty(xs: List[String]) =
+ xs.map(_.trim)
+ .filterNot(_.isEmpty)
+ .map(stringToMarkup)
+
+ def filterEmpty(xs: Map[String, String]) =
+ xs.mapValues(_.trim)
+ .filterNot { case (_, v) => v.isEmpty }
+ .mapValues(stringToMarkup)
+}
+
+case class WikiComment(ent: Representation, parsed: ParsedComment, packages: Map[String, EmulatedPackageRepresentation])
+extends MarkupConversion[Body](packages) {
+
+ def filterEmpty(xs: Map[String,String]) =
+ xs.mapValues(_.toWiki(ent, packages))
+ .filterNot { case (_, v) => v.blocks.isEmpty }
+
+ def filterEmpty(xs: List[String]) =
+ xs.map(_.toWiki(ent, packages))
+
+ def markupToMarkdown(t: Body) =
+ t.show(ent)
+
+ def stringToMarkup(str: String) =
+ str.toWiki(ent, packages)
+
+ def stringToShortMarkdown(str: String) = {
+ val parsed = stringToMarkup(str)
+ parsed.summary.getOrElse(parsed).show(ent)
+ }
+
+ def linkedExceptions(m: Map[String, String]) = {
+ m.mapValues(_.toWiki(ent, packages)).map { case (targetStr, body) =>
+ val link = lookup(Some(ent), packages, targetStr)
+ val newBody = body match {
+ case Body(List(Paragraph(Chain(content)))) =>
+ val descr = Text(" ") +: content
+ val link = makeRepresentationLink(ent, packages, Monospace(Text(targetStr)), targetStr)
+ Body(List(Paragraph(Chain(link +: descr))))
+ case _ => body
+ }
+
+ (targetStr, newBody.show(ent))
+ }
+ }
+}
diff --git a/tastydoc/src/dotty/tastydoc/comment/CommentCleaner.scala b/tastydoc/src/dotty/tastydoc/comment/CommentCleaner.scala
new file mode 100644
index 000000000000..0c244d2dbf86
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/comment/CommentCleaner.scala
@@ -0,0 +1,25 @@
+package dotty.tastydoc
+package comment
+
+trait CommentCleaner {
+ import Regexes._
+ import java.util.regex.Matcher
+
+ def clean(comment: String): List[String] = {
+ def cleanLine(line: String): String = {
+ // Remove trailing whitespaces
+ TrailingWhitespace.replaceAllIn(line, "") match {
+ case CleanCommentLine(ctl) => ctl
+ case tl => tl
+ }
+ }
+ val strippedComment = comment.trim.stripPrefix("/*").stripSuffix("*/")
+ val safeComment = DangerousTags.replaceAllIn(strippedComment, { htmlReplacement(_) })
+ val javadoclessComment = JavadocTags.replaceAllIn(safeComment, { javadocReplacement(_) })
+ val markedTagComment =
+ SafeTags.replaceAllIn(javadoclessComment, { mtch =>
+ Matcher.quoteReplacement(safeTagMarker + mtch.matched + safeTagMarker)
+ })
+ markedTagComment.linesIterator.toList map (cleanLine)
+ }
+}
diff --git a/tastydoc/src/dotty/tastydoc/comment/CommentParser.scala b/tastydoc/src/dotty/tastydoc/comment/CommentParser.scala
new file mode 100644
index 000000000000..17b84258f7db
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/comment/CommentParser.scala
@@ -0,0 +1,219 @@
+package dotty.tastydoc
+package comment
+
+import scala.collection.mutable
+import scala.util.matching.Regex
+import com.vladsch.flexmark.util.ast.{ Node => MarkdownNode }
+import com.vladsch.flexmark.parser.{ Parser => MarkdownParser }
+import dotty.tastydoc.representations._
+
+trait CommentParser {
+ import Regexes._
+
+ /** Parses a raw comment string into a `Comment` object.
+ * @param packages all packages parsed by Scaladoc tool, used for lookup
+ * @param cleanComment a cleaned comment to be parsed
+ * @param src the raw comment source string.
+ * @param span the position of the comment in source.
+ */
+ def parse(
+ representation: Representation,
+ packages: Map[String, EmulatedPackageRepresentation],
+ comment: List[String],
+ src: String
+ ): ParsedComment = {
+
+ /** Parses a comment (in the form of a list of lines) to a `Comment`
+ * instance, recursively on lines. To do so, it splits the whole comment
+ * into main body and tag bodies, then runs the `WikiParser` on each body
+ * before creating the comment instance.
+ *
+ * @param docBody The body of the comment parsed until now.
+ * @param tags All tags parsed until now.
+ * @param lastTagKey The last parsed tag, or `None` if the tag section
+ * hasn't started. Lines that are not tagged are part
+ * of the previous tag or, if none exists, of the body.
+ * @param remaining The lines that must still recursively be parsed.
+ * @param inCodeBlock Whether the next line is part of a code block (in
+ * which no tags must be read).
+ */
+ def parseComment (
+ docBody: StringBuilder,
+ tags: Map[TagKey, List[String]],
+ lastTagKey: Option[TagKey],
+ remaining: List[String],
+ inCodeBlock: Boolean
+ ): ParsedComment = remaining match {
+
+ case CodeBlockStartRegex(before, marker, after) :: ls if (!inCodeBlock) =>
+ if (!before.trim.isEmpty && !after.trim.isEmpty)
+ parseComment(docBody, tags, lastTagKey, before :: marker :: after :: ls, inCodeBlock = false)
+ else if (!before.trim.isEmpty)
+ parseComment(docBody, tags, lastTagKey, before :: marker :: ls, inCodeBlock = false)
+ else if (!after.trim.isEmpty)
+ parseComment(docBody, tags, lastTagKey, marker :: after :: ls, inCodeBlock = true)
+ else lastTagKey match {
+ case Some(key) =>
+ val value =
+ ((tags get key): @unchecked) match {
+ case Some(b :: bs) => (b + endOfLine + marker) :: bs
+ case None => oops("lastTagKey set when no tag exists for key")
+ }
+ parseComment(docBody, tags + (key -> value), lastTagKey, ls, inCodeBlock = true)
+ case None =>
+ parseComment(docBody append endOfLine append marker, tags, lastTagKey, ls, inCodeBlock = true)
+ }
+
+ case CodeBlockEndRegex(before, marker, after) :: ls => {
+ if (!before.trim.isEmpty && !after.trim.isEmpty)
+ parseComment(docBody, tags, lastTagKey, before :: marker :: after :: ls, inCodeBlock = true)
+ if (!before.trim.isEmpty)
+ parseComment(docBody, tags, lastTagKey, before :: marker :: ls, inCodeBlock = true)
+ else if (!after.trim.isEmpty)
+ parseComment(docBody, tags, lastTagKey, marker :: after :: ls, inCodeBlock = false)
+ else lastTagKey match {
+ case Some(key) =>
+ val value =
+ ((tags get key): @unchecked) match {
+ case Some(b :: bs) => (b + endOfLine + marker) :: bs
+ case None => oops("lastTagKey set when no tag exists for key")
+ }
+ parseComment(docBody, tags + (key -> value), lastTagKey, ls, inCodeBlock = false)
+ case None =>
+ parseComment(docBody append endOfLine append marker, tags, lastTagKey, ls, inCodeBlock = false)
+ }
+ }
+
+ case SymbolTagRegex(name, sym, body) :: ls if (!inCodeBlock) => {
+ val key = SymbolTagKey(name, sym)
+ val value = body :: tags.getOrElse(key, Nil)
+ parseComment(docBody, tags + (key -> value), Some(key), ls, inCodeBlock)
+ }
+
+ case SimpleTagRegex(name, body) :: ls if (!inCodeBlock) => {
+ val key = SimpleTagKey(name)
+ val value = body :: tags.getOrElse(key, Nil)
+ parseComment(docBody, tags + (key -> value), Some(key), ls, inCodeBlock)
+ }
+
+ case SingleTagRegex(name) :: ls if (!inCodeBlock) => {
+ val key = SimpleTagKey(name)
+ val value = "" :: tags.getOrElse(key, Nil)
+ parseComment(docBody, tags + (key -> value), Some(key), ls, inCodeBlock)
+ }
+
+ case line :: ls if (lastTagKey.isDefined) => {
+ val newtags = if (!line.isEmpty) {
+ val key = lastTagKey.get
+ val value =
+ ((tags get key): @unchecked) match {
+ case Some(b :: bs) => (b + endOfLine + line) :: bs
+ case None => oops("lastTagKey set when no tag exists for key")
+ }
+ tags + (key -> value)
+ } else tags
+ parseComment(docBody, newtags, lastTagKey, ls, inCodeBlock)
+ }
+
+ case line :: ls => {
+ if (docBody.length > 0) docBody append endOfLine
+ docBody append line
+ parseComment(docBody, tags, lastTagKey, ls, inCodeBlock)
+ }
+
+ case Nil => {
+ // Take the {inheritance, content} diagram keys aside, as it doesn't need any parsing
+ val inheritDiagramTag = SimpleTagKey("inheritanceDiagram")
+ val contentDiagramTag = SimpleTagKey("contentDiagram")
+
+ val inheritDiagramText: List[String] = tags.get(inheritDiagramTag) match {
+ case Some(list) => list
+ case None => List.empty
+ }
+
+ val contentDiagramText: List[String] = tags.get(contentDiagramTag) match {
+ case Some(list) => list
+ case None => List.empty
+ }
+
+ val stripTags = List(inheritDiagramTag, contentDiagramTag, SimpleTagKey("template"), SimpleTagKey("documentable"))
+ val tagsWithoutDiagram = tags.filterNot(pair => stripTags.contains(pair._1))
+
+ val bodyTags: mutable.Map[TagKey, List[String]] =
+ mutable.Map((tagsWithoutDiagram).toSeq: _*)
+
+ def allTags(key: SimpleTagKey): List[String] =
+ (bodyTags remove key).getOrElse(Nil).reverse
+
+ def allSymsOneTag(key: TagKey, filterEmpty: Boolean = true): Map[String, String] = {
+ val keys: Seq[SymbolTagKey] =
+ bodyTags.keys.toSeq flatMap {
+ case stk: SymbolTagKey if (stk.name == key.name) => Some(stk)
+ case stk: SimpleTagKey if (stk.name == key.name) =>
+ // dottydoc.println(s"$span: tag '@${stk.name}' must be followed by a symbol name")
+ None
+ case _ => None
+ }
+ val pairs: Seq[(String, String)] =
+ for (key <- keys) yield {
+ val bs = (bodyTags remove key).get
+ // if (bs.length > 1)
+ // dottydoc.println(s"$span: only one '@${key.name}' tag for symbol ${key.symbol} is allowed")
+ (key.symbol, bs.head)
+ }
+ Map.empty[String, String] ++ pairs
+ }
+
+ val cmt = ParsedComment(
+ body = docBody.toString,
+ authors = allTags(SimpleTagKey("author")),
+ see = allTags(SimpleTagKey("see")),
+ result = allTags(SimpleTagKey("return")),
+ throws = allSymsOneTag(SimpleTagKey("throws")),
+ valueParams = allSymsOneTag(SimpleTagKey("param")),
+ typeParams = allSymsOneTag(SimpleTagKey("tparam")),
+ version = allTags(SimpleTagKey("version")),
+ since = allTags(SimpleTagKey("since")),
+ todo = allTags(SimpleTagKey("todo")),
+ deprecated = allTags(SimpleTagKey("deprecated")),
+ note = allTags(SimpleTagKey("note")),
+ example = allTags(SimpleTagKey("example")),
+ constructor = allTags(SimpleTagKey("constructor")),
+ group = allTags(SimpleTagKey("group")),
+ groupDesc = allSymsOneTag(SimpleTagKey("groupdesc")),
+ groupNames = allSymsOneTag(SimpleTagKey("groupname")),
+ groupPrio = allSymsOneTag(SimpleTagKey("groupprio")),
+ hideImplicitConversions = allTags(SimpleTagKey("hideImplicitConversion")),
+ shortDescription = allTags(SimpleTagKey("shortDescription"))
+ )
+
+ // for ((key, _) <- bodyTags) ctx.docbase.warn(
+ // hl"Tag '${"@" + key.name}' is not recognised",
+ // // FIXME: here the position is stretched out over the entire comment,
+ // // with the point being at the very end. This ensures that the entire
+ // // comment will be visible in error reporting. A more fine-grained
+ // // reporting would be amazing here.
+ // entity.symbol.sourcePosition(Span(span.start, span.end, span.end))
+ // )
+
+ cmt
+ }
+ }
+
+ parseComment(new StringBuilder(comment.size), Map.empty, None, comment, inCodeBlock = false)
+ }
+
+ /** A key used for a tag map. The key is built from the name of the tag and
+ * from the linked symbol if the tag has one.
+ * Equality on tag keys is structural. */
+ private sealed abstract class TagKey {
+ def name: String
+ }
+
+ private /*final*/ case class SimpleTagKey(name: String) extends TagKey
+ private /*final*/ case class SymbolTagKey(name: String, symbol: String) extends TagKey
+
+ /** Something that should not have happened, happened, and Scaladoc should exit. */
+ private def oops(msg: String): Nothing =
+ throw new IllegalArgumentException("program logic: " + msg)
+}
diff --git a/tastydoc/src/dotty/tastydoc/comment/CommentRegex.scala b/tastydoc/src/dotty/tastydoc/comment/CommentRegex.scala
new file mode 100644
index 000000000000..cd17e06999bf
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/comment/CommentRegex.scala
@@ -0,0 +1,82 @@
+package dotty.tastydoc.comment
+
+import scala.util.matching.Regex
+
+object Regexes {
+ val TrailingWhitespace = """\s+$""".r
+
+ /** The body of a line, dropping the (optional) start star-marker,
+ * one leading whitespace and all trailing whitespace
+ */
+ val CleanCommentLine =
+ new Regex("""(?:\s*\*\s?\s?)?(.*)""")
+
+ /** Dangerous HTML tags that should be replaced by something safer,
+ * such as wiki syntax, or that should be dropped
+ */
+ val DangerousTags =
+ new Regex("""<(/?(div|ol|ul|li|h[1-6]|p))( [^>]*)?/?>|""")
+
+ /** Javadoc tags that should be replaced by something useful, such as wiki
+ * syntax, or that should be dropped. */
+ val JavadocTags =
+ new Regex("""\{\@(code|docRoot|linkplain|link|literal|value)\p{Zs}*([^}]*)\}""")
+
+ /** Maps a javadoc tag to a useful wiki replacement, or an empty string if it cannot be salvaged. */
+ def javadocReplacement(mtch: Regex.Match): String = {
+ mtch.group(1) match {
+ case "code" => "" + mtch.group(2) + ""
+ case "docRoot" => ""
+ case "link" => "`[[" + mtch.group(2) + "]]`"
+ case "linkplain" => "[[" + mtch.group(2) + "]]"
+ case "literal" => "`" + mtch.group(2) + "`"
+ case "value" => "`" + mtch.group(2) + "`"
+ case _ => ""
+ }
+ }
+
+ /** Maps a dangerous HTML tag to a safe wiki replacement, or an empty string
+ * if it cannot be salvaged. */
+ def htmlReplacement(mtch: Regex.Match): String = mtch.group(1) match {
+ case "p" | "div" => "\n\n"
+ case "h1" => "\n= "
+ case "/h1" => " =\n"
+ case "h2" => "\n== "
+ case "/h2" => " ==\n"
+ case "h3" => "\n=== "
+ case "/h3" => " ===\n"
+ case "h4" | "h5" | "h6" => "\n==== "
+ case "/h4" | "/h5" | "/h6" => " ====\n"
+ case "li" => "\n * - "
+ case _ => ""
+ }
+
+ /** Safe HTML tags that can be kept. */
+ val SafeTags =
+ new Regex("""((&\w+;)|(&#\d+;)|(]*)?/?>))""")
+
+ val safeTagMarker = '\u000E'
+ val endOfLine = '\u000A'
+ val endOfText = '\u0003'
+
+ /** A Scaladoc tag not linked to a symbol and not followed by text */
+ val SingleTagRegex =
+ new Regex("""\s*@(\S+)\s*""")
+
+ /** A Scaladoc tag not linked to a symbol. Returns the name of the tag, and the rest of the line. */
+ val SimpleTagRegex =
+ new Regex("""\s*@(\S+)\s+(.*)""")
+
+ /** A Scaladoc tag linked to a symbol. Returns the name of the tag, the name
+ * of the symbol, and the rest of the line. */
+ val SymbolTagRegex =
+ new Regex("""\s*@(param|tparam|throws|groupdesc|groupname|groupprio)\s+(\S*)\s*(.*)""")
+
+ /** The start of a Scaladoc code block */
+ val CodeBlockStartRegex =
+ new Regex("""(.*?)((?:\{\{\{)|(?:\u000E]*)?>\u000E))(.*)""")
+
+ /** The end of a Scaladoc code block */
+ val CodeBlockEndRegex =
+ new Regex("""(.*?)((?:\}\}\})|(?:\u000E\u000E))(.*)""")
+}
diff --git a/tastydoc/src/dotty/tastydoc/comment/HtmlParsers.scala b/tastydoc/src/dotty/tastydoc/comment/HtmlParsers.scala
new file mode 100644
index 000000000000..10417df10a71
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/comment/HtmlParsers.scala
@@ -0,0 +1,188 @@
+package dotty.tastydoc.comment
+
+import util.MemberLookup
+
+import dotty.tastydoc.representations._
+
+import java.util.{ Arrays }
+
+import com.vladsch.flexmark.util.ast.{ Node => MarkdownNode}
+import com.vladsch.flexmark.formatter.Formatter
+import com.vladsch.flexmark.parser.Parser
+import com.vladsch.flexmark.util.sequence.CharSubSequence
+import com.vladsch.flexmark.parser.ParserEmulationProfile
+import com.vladsch.flexmark.ext.gfm.tables.TablesExtension
+import com.vladsch.flexmark.ext.gfm.strikethrough.StrikethroughExtension
+import com.vladsch.flexmark.ext.gfm.tasklist.TaskListExtension
+import com.vladsch.flexmark.ext.emoji.EmojiExtension
+import com.vladsch.flexmark.ext.autolink.AutolinkExtension
+import com.vladsch.flexmark.ext.anchorlink.AnchorLinkExtension
+import com.vladsch.flexmark.ext.yaml.front.matter.YamlFrontMatterExtension
+import com.vladsch.flexmark.util.options.{ DataHolder, MutableDataSet }
+
+object HtmlParsers {
+
+ val markdownOptions: DataHolder =
+ new MutableDataSet()
+ .setFrom(ParserEmulationProfile.KRAMDOWN.getOptions)
+ .set(Parser.EXTENSIONS, Arrays.asList(
+ TablesExtension.create(),
+ TaskListExtension.create(),
+ AutolinkExtension.create(),
+ AnchorLinkExtension.create(),
+ EmojiExtension.create(),
+ YamlFrontMatterExtension.create(),
+ StrikethroughExtension.create()
+ ))
+ .set(EmojiExtension.ROOT_IMAGE_PATH,
+ "https://github.global.ssl.fastly.net/images/icons/emoji/")
+
+ val RENDERER = Formatter.builder(markdownOptions).build()
+
+ implicit class StringToMarkdown(val text: String) extends AnyVal {
+ def toMarkdown(origin: Representation, packages: Map[String, EmulatedPackageRepresentation]): MarkdownNode = {
+ import com.vladsch.flexmark.ast.Link
+ import com.vladsch.flexmark.util.ast.{Visitor, VisitHandler, NodeVisitor }
+
+ val inlineToMarkdown = InlineToMarkdown(origin)
+
+ val node = Parser.builder(markdownOptions)
+ .build.parse(text)
+
+ def isOuter(url: String) =
+ url.startsWith("http://") ||
+ url.startsWith("https://") ||
+ url.startsWith("ftp://") ||
+ url.startsWith("ftps://")
+
+ def isRelative(url: String) =
+ url.startsWith("../") ||
+ url.startsWith("./")
+
+ val linkVisitor = new NodeVisitor(
+ new VisitHandler(classOf[Link], new Visitor[Link] with MemberLookup {
+ def queryToUrl(title: String, link: String) = makeRepresentationLink(origin, packages, Text(title), link).link match {
+ case Tooltip(_) => "#"
+ case LinkToExternal(_, url) => url
+ case LinkToRepresentation(t: Representation) => t match {
+ case e: Representation with Members => inlineToMarkdown.relativePath(t)
+ case x => x.parentRepresentation.fold("#") { xpar => inlineToMarkdown.relativePath(xpar) }
+ }
+ }
+
+ override def visit(link: Link) = {
+ val linkUrl = link.getUrl.toString
+ if (!isOuter(linkUrl) && !isRelative(linkUrl))
+ link.setUrl(CharSubSequence.of(queryToUrl(link.getTitle.toString, linkUrl)))
+ }
+ })
+ )
+
+ linkVisitor.visit(node)
+ node
+ }
+
+ def toMarkdownString(origin: Representation, packages: Map[String, EmulatedPackageRepresentation]): String =
+ toMarkdown(origin, packages).show
+ }
+
+ implicit class MarkdownToHtml(val markdown: MarkdownNode) extends AnyVal {
+ def show: String =
+ RENDERER.render(markdown)
+
+ def shortenAndShow: String =
+ (new MarkdownShortener).shorten(markdown).show
+ }
+
+ implicit class StringToWiki(val text: String) extends AnyVal {
+ def toWiki(origin: Representation, packages: Map[String, EmulatedPackageRepresentation]): Body =
+ new WikiParser(origin, packages, text).document()
+ }
+
+ implicit class BodyToMarkdown(val body: Body) extends AnyVal {
+ def show(origin: Representation): String = {
+ val inlineToMarkdown = InlineToMarkdown(origin)
+
+ def bodyToMarkdown(body: Body): String =
+ (body.blocks map blockToMarkdown).mkString
+
+ def listItemsToMarkdown(items: Seq[Block], level: Int = 0, ordered: Boolean = false): String ={
+ if(ordered){
+ items.foldLeft(("", 1)){ (list, item) =>
+ item match {
+ case OrderedList(itemsLvl2, _) => val x = itemsLvl2; (list._1 + s"${listItemsToMarkdown(x, level + 1, true)}\n", list._2 + 1)
+ case UnorderedList(itemsLvl2) => val x = itemsLvl2; (list._1 + s"${listItemsToMarkdown(x, level + 1, false)}\n", list._2 + 1)
+ case Paragraph(inl) => (list._1 + s"${"\t"*level}${list._2}. ${inlineToMarkdown(inl)}\n", list._2 + 1)
+ case block => (list._1 + s"${"\t"*level}${list._2}. ${blockToMarkdown(block)}\n", list._2 + 1)
+ }
+ }._1
+ }else{
+ items.foldLeft(""){ (list, item) =>
+ item match {
+ case OrderedList(itemsLvl2, _) => val x = itemsLvl2; list + s"${listItemsToMarkdown(x, level + 1, true)}\n"
+ case UnorderedList(itemsLvl2) => val x = itemsLvl2; list + s"${listItemsToMarkdown(x, level + 1, false)}\n"
+ case Paragraph(inl) => list + s"${"\t"*level}* ${inlineToMarkdown(inl)}\n"
+ case block => list + s"${"\t"*level}* ${blockToMarkdown(block)}\n"
+ }
+ }
+ }
+ }
+
+ def blockToMarkdown(block: Block): String = {
+ (block match {
+ case Title(in, 1) => s"# ${inlineToMarkdown(in)}"
+ case Title(in, 2) => s"## ${inlineToMarkdown(in)}"
+ case Title(in, 3) => s"### ${inlineToMarkdown(in)}"
+ case Title(in, _) => s"#### ${inlineToMarkdown(in)}"
+ case Paragraph(in) => s"${inlineToMarkdown(in)}"
+ case Code(data) => s"```scala\n$data\n```"
+ case UnorderedList(items) => s"${listItemsToMarkdown(items)}"
+ case OrderedList(items, listStyle) => s"${listItemsToMarkdown(items, ordered=true)}"
+ case DefinitionList(items) =>
+ s"${items map { case (t, d) => s"${inlineToMarkdown(t)}\n: ${blockToMarkdown(d)}" } }" //Not widely supported
+ case HorizontalRule() =>
+ "***"
+ }) +
+ "\n"
+ }
+
+ bodyToMarkdown(body)
+ }
+ }
+
+ case class InlineToMarkdown(origin: Representation) {
+ def apply(inl: Inline) = toMarkdown(inl)
+
+ def relativePath(target: Representation) =
+ util.traversing.relativePath(origin, target)
+
+ def toMarkdown(inl: Inline): String = inl match {
+ case Chain(items) => (items map toMarkdown).mkString
+ case Italic(in) => s"*${toMarkdown(in)}*"
+ case Bold(in) => s"**${toMarkdown(in)}**"
+ case Underline(in) => s"__${toMarkdown(in)}__"
+ case Superscript(in) => s"${toMarkdown(in)}" //No Markdown equival
+ case Subscript(in) => s"${toMarkdown(in) }" //No Markdown equivalent
+ case Link(raw, title) => s"[${toMarkdown(title)}]($raw)"
+ case Monospace(in) => s"`${toMarkdown(in)}`"
+ case Text(text) => text
+ case Summary(in) => toMarkdown(in)
+ case HtmlTag(tag) => tag
+ case RepresentationLink(target, link) => enityLinktoMarkdown(target, link)
+ }
+
+ def enityLinktoMarkdown(target: Inline, link: LinkTo) = link match {
+ case Tooltip(_) => toMarkdown(target)
+ case LinkToExternal(n, url) => s"[$n]($url)"
+ case LinkToRepresentation(t: Representation) => t match {
+ // Representation is a package member
+ case e: Representation with Members =>
+ s"[${toMarkdown(target)}](${relativePath(t)}.md)"
+ // Representation is a Val / Def
+ case x => x.parentRepresentation.fold(toMarkdown(target)) { xpar =>
+ s"[${toMarkdown(target)}](${relativePath(xpar)}.md#${x.name})"
+ }
+ }
+ }
+ }
+}
diff --git a/tastydoc/src/dotty/tastydoc/comment/MarkdownShortener.scala b/tastydoc/src/dotty/tastydoc/comment/MarkdownShortener.scala
new file mode 100644
index 000000000000..e81e9c481d2b
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/comment/MarkdownShortener.scala
@@ -0,0 +1,82 @@
+package dotty.tastydoc
+package comment
+
+/** The `MarkdownShortener` takes a node and *mutates* it and all children so
+ * that the displayed length of the generated HTML doesn't exceeed `maxLen`.
+ * This number defaults to 150 characters.
+ *
+ * @note calling `shorten` **will** mutate the Markdown AST node.
+ */
+class MarkdownShortener {
+ import com.vladsch.flexmark.ast.{Text, Code, Image, FencedCodeBlock, BulletList, BulletListItem, OrderedListItem}
+ import com.vladsch.flexmark.util.ast.{Node, NodeVisitor, VisitHandler, Visitor}
+
+ def shorten(node: Node, maxLen: Int = 150): Node = {
+ var len = 0
+ var didUnlink = false
+
+ def count(node: Node, length: => Int, shortenOrUnlink: Int => Unit) = {
+ val remaining = math.max(maxLen - len, 0)
+ if (didUnlink || remaining == 0) node.unlink()
+ else {
+ if (length <= remaining) len += length
+ else {
+ shortenOrUnlink(remaining)
+ len = maxLen
+ }
+ }
+ }
+
+ val nodeVisitor = new NodeVisitor(
+ new VisitHandler(classOf[Text], new Visitor[Text] {
+ override def visit(node: Text) = count(
+ node,
+ node.getChars.length,
+ remaining => node.setChars(
+ node.getChars.subSequence(0, remaining).trimEnd.append("...")
+ )
+ )
+ }),
+ new VisitHandler(classOf[Code], new Visitor[Code] {
+ override def visit(node: Code) = count(
+ node,
+ node.getText.length,
+ remaining => node.setText(
+ node.getText.subSequence(0, remaining).trimEnd.append("...")
+ )
+ )
+ }),
+ new VisitHandler(classOf[Image], new Visitor[Image] {
+ override def visit(node: Image) = count(node, maxLen, _ => node.unlink())
+ }),
+ new VisitHandler(classOf[FencedCodeBlock], new Visitor[FencedCodeBlock] {
+ override def visit(node: FencedCodeBlock) = count(node, maxLen, _ => node.unlink())
+ }),
+ new VisitHandler(classOf[BulletListItem], new Visitor[BulletListItem] {
+ override def visit(node: BulletListItem) = count(
+ node,
+ if (didUnlink) maxLen
+ else node.getSegments.map(_.length).reduceLeft(_ + _),
+ _ => {
+ node.unlink()
+ didUnlink = true // unlink all following bullets
+ }
+ )
+ }),
+ new VisitHandler(classOf[OrderedListItem], new Visitor[OrderedListItem] {
+ override def visit(node: OrderedListItem) = count(
+ node,
+ if (didUnlink) maxLen
+ else node.getSegments.map(_.length).reduceLeft(_ + _),
+ _ => {
+ node.unlink()
+ didUnlink = true // unlink all following bullets
+ }
+ )
+ })
+ )
+
+ nodeVisitor.visit(node)
+ node
+ }
+}
diff --git a/tastydoc/src/dotty/tastydoc/comment/WikiParser.scala b/tastydoc/src/dotty/tastydoc/comment/WikiParser.scala
new file mode 100644
index 000000000000..38e17e9c1f80
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/comment/WikiParser.scala
@@ -0,0 +1,541 @@
+package dotty.tastydoc
+package comment
+
+import util.MemberLookup
+import representations._
+import scala.collection.mutable
+
+import Regexes._
+
+/** Original wikiparser from NSC
+ * @author Ingo Maier
+ * @author Manohar Jonnalagedda
+ * @author Gilles Dubochet
+ */
+private[comment] final class WikiParser(
+ representation: Representation,
+ packages: Map[String, EmulatedPackageRepresentation],
+ val buffer: String
+) extends CharReader(buffer) with MemberLookup { wiki =>
+ var summaryParsed = false
+
+ def document(): Body = {
+ val blocks = new mutable.ListBuffer[Block]
+ while (char != endOfText)
+ blocks += block()
+ Body(blocks.toList)
+ }
+
+ /* BLOCKS */
+
+ /** {{{ block ::= code | title | hrule | listBlock | para }}} */
+ def block(): Block = {
+ if (checkSkipInitWhitespace("{{{"))
+ code()
+ else if (checkSkipInitWhitespace('='))
+ title()
+ else if (checkSkipInitWhitespace("----"))
+ hrule()
+ else if (checkList)
+ listBlock()
+ else {
+ para()
+ }
+ }
+
+ /** listStyle ::= '-' spc | '1.' spc | 'I.' spc | 'i.' spc | 'A.' spc | 'a.' spc
+ * Characters used to build lists and their constructors */
+ protected val listStyles = Map[String, (Seq[Block] => Block)](
+ "- " -> ( UnorderedList(_) ),
+ "1. " -> ( OrderedList(_,"decimal") ),
+ "I. " -> ( OrderedList(_,"upperRoman") ),
+ "i. " -> ( OrderedList(_,"lowerRoman") ),
+ "A. " -> ( OrderedList(_,"upperAlpha") ),
+ "a. " -> ( OrderedList(_,"lowerAlpha") )
+ )
+
+ /** Checks if the current line is formed with more than one space and one the listStyles */
+ def checkList =
+ (countWhitespace > 0) && (listStyles.keys exists { checkSkipInitWhitespace(_) })
+
+ /** {{{
+ * nListBlock ::= nLine { mListBlock }
+ * nLine ::= nSpc listStyle para '\n'
+ * }}}
+ * Where n and m stand for the number of spaces. When `m > n`, a new list is nested. */
+ def listBlock(): Block = {
+
+ /** Consumes one list item block and returns it, or None if the block is
+ * not a list or a different list. */
+ def listLine(indent: Int, style: String): Option[Block] =
+ if (countWhitespace > indent && checkList)
+ Some(listBlock())
+ else if (countWhitespace != indent || !checkSkipInitWhitespace(style))
+ None
+ else {
+ jumpWhitespace()
+ jump(style)
+ val p = Paragraph(getInline(isInlineEnd = false))
+ blockEnded("end of list line ")
+ Some(p)
+ }
+
+ /** Consumes all list item blocks (possibly with nested lists) of the
+ * same list and returns the list block. */
+ def listLevel(indent: Int, style: String): Block = {
+ val lines = mutable.ListBuffer.empty[Block]
+ var line: Option[Block] = listLine(indent, style)
+ while (line.isDefined) {
+ lines += line.get
+ line = listLine(indent, style)
+ }
+ val constructor = listStyles(style)
+ constructor(lines)
+ }
+
+ val indent = countWhitespace
+ val style = (listStyles.keys find { checkSkipInitWhitespace(_) }).getOrElse(listStyles.keys.head)
+ listLevel(indent, style)
+ }
+
+ def code(): Block = {
+ jumpWhitespace()
+ jump("{{{")
+ val str = readUntil("}}}")
+ if (char == endOfText)
+ reportError("unclosed code block")
+ else
+ jump("}}}")
+ blockEnded("code block")
+ Code(normalizeIndentation(str))
+ }
+
+ /** {{{ title ::= ('=' inline '=' | "==" inline "==" | ...) '\n' }}} */
+ def title(): Block = {
+ jumpWhitespace()
+ val inLevel = repeatJump('=')
+ val text = getInline(check("=" * inLevel))
+ val outLevel = repeatJump('=', inLevel)
+ if (inLevel != outLevel)
+ reportError("unbalanced or unclosed heading")
+ blockEnded("heading")
+ Title(text, inLevel)
+ }
+
+ /** {{{ hrule ::= "----" { '-' } '\n' }}} */
+ def hrule(): Block = {
+ jumpWhitespace()
+ repeatJump('-')
+ blockEnded("horizontal rule")
+ HorizontalRule()
+ }
+
+ /** {{{ para ::= inline '\n' }}} */
+ def para(): Block = {
+ val p =
+ if (summaryParsed)
+ Paragraph(getInline(isInlineEnd = false))
+ else {
+ val s = summary()
+ val r =
+ if (checkParaEnded()) List(s) else List(s, getInline(isInlineEnd = false))
+ summaryParsed = true
+ Paragraph(Chain(r))
+ }
+ while (char == endOfLine && char != endOfText)
+ nextChar()
+ p
+ }
+
+ /* INLINES */
+
+ val OPEN_TAG = "^<([A-Za-z]+)( [^>]*)?(/?)>$".r
+ val CLOSE_TAG = "^$".r
+ private def readHTMLFrom(begin: HtmlTag): String = {
+ val list = mutable.ListBuffer.empty[String]
+ val stack = mutable.ListBuffer.empty[String]
+
+ begin.close match {
+ case Some(HtmlTag(CLOSE_TAG(s))) =>
+ stack += s
+ case _ =>
+ return ""
+ }
+
+ do {
+ val str = readUntil { char == safeTagMarker || char == endOfText }
+ nextChar()
+
+ list += str
+
+ str match {
+ case OPEN_TAG(s, _, standalone) => {
+ if (standalone != "/") {
+ stack += s
+ }
+ }
+ case CLOSE_TAG(s) => {
+ if (s == stack.last) {
+ stack.remove(stack.length-1)
+ }
+ }
+ case _ => ;
+ }
+ } while (stack.length > 0 && char != endOfText)
+
+ list mkString ""
+ }
+
+ def getInline(isInlineEnd: => Boolean): Inline = {
+
+ def inline0(): Inline = {
+ if (char == safeTagMarker) {
+ val tag = htmlTag()
+ HtmlTag(tag.data + readHTMLFrom(tag))
+ }
+ else if (check("'''")) bold()
+ else if (check("''")) italic()
+ else if (check("`")) monospace()
+ else if (check("__")) underline()
+ else if (check("^")) superscript()
+ else if (check(",,")) subscript()
+ else if (check("[[")) link()
+ else {
+ val str = readUntil {
+ char == safeTagMarker ||
+ check("''") ||
+ char == '`' ||
+ check("__") ||
+ char == '^' ||
+ check(",,") ||
+ check("[[") ||
+ isInlineEnd ||
+ checkParaEnded() ||
+ char == endOfLine
+ }
+ Text(str)
+ }
+ }
+
+ val inlines: List[Inline] = {
+ val iss = mutable.ListBuffer.empty[Inline]
+ iss += inline0()
+ while (!isInlineEnd && !checkParaEnded()) {
+ val skipEndOfLine = if (char == endOfLine) {
+ nextChar()
+ true
+ } else {
+ false
+ }
+
+ val current = inline0()
+ (iss.last, current) match {
+ case (Text(t1), Text(t2)) if skipEndOfLine =>
+ iss.update(iss.length - 1, Text(t1 + endOfLine + t2))
+ case (i1, i2) if skipEndOfLine =>
+ iss ++= List(Text(endOfLine.toString), i2)
+ case _ => iss += current
+ }
+ }
+ iss.toList
+ }
+
+ inlines match {
+ case Nil => Text("")
+ case i :: Nil => i
+ case is => Chain(is)
+ }
+
+ }
+
+ def htmlTag(): HtmlTag = {
+ jump(safeTagMarker)
+ val read = readUntil(safeTagMarker)
+ if (char != endOfText) jump(safeTagMarker)
+ HtmlTag(read)
+ }
+
+ def bold(): Inline = {
+ jump("'''")
+ val i = getInline(check("'''"))
+ jump("'''")
+ Bold(i)
+ }
+
+ def italic(): Inline = {
+ jump("''")
+ val i = getInline(check("''"))
+ jump("''")
+ Italic(i)
+ }
+
+ def monospace(): Inline = {
+ jump("`")
+ val i = getInline(check("`"))
+ jump("`")
+ Monospace(i)
+ }
+
+ def underline(): Inline = {
+ jump("__")
+ val i = getInline(check("__"))
+ jump("__")
+ Underline(i)
+ }
+
+ def superscript(): Inline = {
+ jump("^")
+ val i = getInline(check("^"))
+ if (jump("^")) {
+ Superscript(i)
+ } else {
+ Chain(Seq(Text("^"), i))
+ }
+ }
+
+ def subscript(): Inline = {
+ jump(",,")
+ val i = getInline(check(",,"))
+ jump(",,")
+ Subscript(i)
+ }
+
+ def summary(): Inline = {
+ val i = getInline(checkSentenceEnded())
+ Summary(
+ if (jump("."))
+ Chain(List(i, Text(".")))
+ else
+ i
+ )
+ }
+
+ def link(): Inline = {
+ val SchemeUri = """([a-z]+:.*)""".r
+ jump("[[")
+ val parens = 2 + repeatJump('[')
+ val stop = "]" * parens
+ val target = readUntil { check(stop) || isWhitespaceOrNewLine(char) }
+ val title =
+ if (!check(stop)) Some({
+ jumpWhitespaceOrNewLine()
+ getInline(check(stop))
+ })
+ else None
+ jump(stop)
+
+ (target, title) match {
+ case (SchemeUri(uri), optTitle) =>
+ Link(uri, optTitle getOrElse Text(uri))
+ case (qualName, optTitle) =>
+ makeRepresentationLink(representation, packages, optTitle getOrElse Text(target), target)
+ }
+ }
+
+ /* UTILITY */
+
+ /** {{{ eol ::= { whitespace } '\n' }}} */
+ def blockEnded(blockType: String): Unit = {
+ if (char != endOfLine && char != endOfText) {
+ reportError("no additional content on same line after " + blockType)
+ jumpUntil(endOfLine)
+ }
+ while (char == endOfLine)
+ nextChar()
+ }
+
+ /**
+ * Eliminates the (common) leading spaces in all lines, based on the first line
+ * For indented pieces of code, it reduces the indent to the least whitespace prefix:
+ * {{{
+ * indented example
+ * another indented line
+ * if (condition)
+ * then do something;
+ * ^ this is the least whitespace prefix
+ * }}}
+ */
+ def normalizeIndentation(_code: String): String = {
+
+ val code = _code.replaceAll("\\s+$", "").dropWhile(_ == '\n') // right-trim + remove all leading '\n'
+ val lines = code.split("\n")
+
+ // maxSkip - size of the longest common whitespace prefix of non-empty lines
+ val nonEmptyLines = lines.filter(_.trim.nonEmpty)
+ val maxSkip = if (nonEmptyLines.isEmpty) 0 else nonEmptyLines.map(line => line.prefixLength(_ == ' ')).min
+
+ // remove common whitespace prefix
+ lines.map(line => if (line.trim.nonEmpty) line.substring(maxSkip) else line).mkString("\n")
+ }
+
+ def checkParaEnded(): Boolean = {
+ (char == endOfText) ||
+ ((char == endOfLine) && {
+ val poff = offset
+ nextChar() // read EOL
+ val ok = {
+ checkSkipInitWhitespace(endOfLine) ||
+ checkSkipInitWhitespace('=') ||
+ checkSkipInitWhitespace("{{{") ||
+ checkList ||
+ checkSkipInitWhitespace('\u003D')
+ }
+ offset = poff
+ ok
+ })
+ }
+
+ def checkSentenceEnded(): Boolean = {
+ (char == '.') && {
+ val poff = offset
+ nextChar() // read '.'
+ val ok = char == endOfText || char == endOfLine || isWhitespace(char)
+ offset = poff
+ ok
+ }
+ }
+
+ def reportError(message: String) = println(s"$message")
+}
+
+sealed class CharReader(buffer: String) { reader =>
+
+ var offset: Int = 0
+ def char: Char =
+ if (offset >= buffer.length) endOfText else buffer charAt offset
+
+ final def nextChar() =
+ offset += 1
+
+ final def check(chars: String): Boolean = {
+ val poff = offset
+ val ok = jump(chars)
+ offset = poff
+ ok
+ }
+
+ def checkSkipInitWhitespace(c: Char): Boolean = {
+ val poff = offset
+ jumpWhitespace()
+ val ok = jump(c)
+ offset = poff
+ ok
+ }
+
+ def checkSkipInitWhitespace(chars: String): Boolean = {
+ val poff = offset
+ jumpWhitespace()
+ val (ok0, chars0) =
+ if (chars.charAt(0) == ' ')
+ (offset > poff, chars substring 1)
+ else
+ (true, chars)
+ val ok = ok0 && jump(chars0)
+ offset = poff
+ ok
+ }
+
+ def countWhitespace: Int = {
+ var count = 0
+ val poff = offset
+ while (isWhitespace(char) && char != endOfText) {
+ nextChar()
+ count += 1
+ }
+ offset = poff
+ count
+ }
+
+ /* Jumpers */
+
+ /** Jumps a character and consumes it
+ * @return true only if the correct character has been jumped */
+ final def jump(ch: Char): Boolean = {
+ if (char == ch) {
+ nextChar()
+ true
+ }
+ else false
+ }
+
+ /** Jumps all the characters in chars, consuming them in the process.
+ * @return true only if the correct characters have been jumped
+ */
+ final def jump(chars: String): Boolean = {
+ var index = 0
+ while (index < chars.length && char == chars.charAt(index) && char != endOfText) {
+ nextChar()
+ index += 1
+ }
+ index == chars.length
+ }
+
+ final def repeatJump(c: Char, max: Int = Int.MaxValue): Int = {
+ var count = 0
+ while (jump(c) && count < max)
+ count += 1
+ count
+ }
+
+ final def jumpUntil(ch: Char): Int = {
+ var count = 0
+ while (char != ch && char != endOfText) {
+ nextChar()
+ count += 1
+ }
+ count
+ }
+
+ final def jumpUntil(pred: => Boolean): Int = {
+ var count = 0
+ while (!pred && char != endOfText) {
+ nextChar()
+ count += 1
+ }
+ count
+ }
+
+ def jumpWhitespace() = jumpUntil(!isWhitespace(char))
+
+ def jumpWhitespaceOrNewLine() = jumpUntil(!isWhitespaceOrNewLine(char))
+
+ /* Readers */
+ final def readUntil(c: Char): String = {
+ withRead {
+ while (char != c && char != endOfText) {
+ nextChar()
+ }
+ }
+ }
+
+ final def readUntil(chars: String): String = {
+ assert(chars.length > 0)
+ withRead {
+ val c = chars.charAt(0)
+ while (!check(chars) && char != endOfText) {
+ nextChar()
+ while (char != c && char != endOfText)
+ nextChar()
+ }
+ }
+ }
+
+ final def readUntil(pred: => Boolean): String = {
+ withRead {
+ while (char != endOfText && !pred) {
+ nextChar()
+ }
+ }
+ }
+
+ private def withRead(read: => Unit): String = {
+ val start = offset
+ read
+ buffer.substring(start, offset)
+ }
+
+ /* Chars classes */
+ def isWhitespace(c: Char) = c == ' ' || c == '\t'
+
+ def isWhitespaceOrNewLine(c: Char) = isWhitespace(c) || c == '\n'
+}
diff --git a/tastydoc/src/dotty/tastydoc/comment/util/MemberLookup.scala b/tastydoc/src/dotty/tastydoc/comment/util/MemberLookup.scala
new file mode 100644
index 000000000000..b67059f496b3
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/comment/util/MemberLookup.scala
@@ -0,0 +1,88 @@
+package dotty.tastydoc
+package comment
+package util
+
+import dotty.tastydoc.representations._
+
+trait MemberLookup {
+ /** Performs a lookup based on the provided (pruned) query string
+ *
+ * Will return a `Tooltip` if unsuccessful, otherwise a LinkToRepresentation or
+ * LinkToExternal
+ */
+ def lookup(representation: Option[Representation], packages: Map[String, EmulatedPackageRepresentation], query: String): Option[Representation] = {
+ val notFound: Option[Representation] = None
+ val querys = query.split("\\.").toList
+
+ /** Looks for the specified Representation among `ent`'s members */
+ def localLookup(ent: Representation with Members, searchStr: String): Option[Representation] =
+ ent
+ .members
+ .collect { case x if x.name == searchStr => x }
+ .sortBy(_.path.last)
+ .headOption
+
+ /** Looks for a Representation down in the structure, if the search list is Nil,
+ * the search stops
+ */
+ def downwardLookup(ent: Representation with Members, search: List[String]): Option[Representation] =
+ search match {
+ case Nil => notFound
+ case x :: Nil =>
+ localLookup(ent, x)
+ case x :: xs =>
+ ent
+ .members
+ .collectFirst {
+ case e: Representation with Members if e.name == x => e
+ case e: Representation with Members if e.name == x.init && x.last == '$' => e
+ }
+ .fold(notFound)(e => downwardLookup(e, xs))
+ }
+
+ /** Finds package with longest matching name, then does downwardLookup in
+ * the package
+ */
+ def globalLookup: Option[Representation] = {
+ def longestMatch(list: List[String]): List[String] =
+ if (list eq Nil) Nil
+ else
+ packages
+ .get(list.mkString("."))
+ .map(_ => list)
+ .getOrElse(longestMatch(list.dropRight(1)))
+
+ longestMatch(querys) match {
+ case Nil => notFound
+ case xs => downwardLookup(packages(xs.mkString(".")), querys diff xs)
+ }
+ }
+
+ (querys, representation) match {
+ case (xs, None) => globalLookup
+ case (x :: Nil, Some(e: Representation with Members)) =>
+ localLookup(e, x)
+ case (x :: _, Some(e: Representation with Members)) if x == e.name =>
+ downwardLookup(e, querys)
+ case (x :: xs, _) =>
+ if (xs.nonEmpty) globalLookup
+ else lookup(representation, packages, "scala." + query)
+ case (Nil, _) =>
+ throw new IllegalArgumentException("`query` cannot be empty")
+ }
+ }
+
+ def makeRepresentationLink(
+ representation: Representation,
+ packages: Map[String, EmulatedPackageRepresentation],
+ title: Inline,
+ query: String
+ ): RepresentationLink = {
+ val link =
+ lookup(Some(representation), packages, query)
+ .map(LinkToRepresentation)
+ .getOrElse(Tooltip(query))
+
+ RepresentationLink(title, link)
+ }
+}
diff --git a/tastydoc/src/dotty/tastydoc/comment/util/traversing.scala b/tastydoc/src/dotty/tastydoc/comment/util/traversing.scala
new file mode 100644
index 000000000000..c93f407d0b57
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/comment/util/traversing.scala
@@ -0,0 +1,45 @@
+package dotty.tastydoc
+package comment
+package util
+
+import representations._
+
+object traversing {
+
+ def mutateEntities(e: Representation)(trans: Representation => Unit): Unit = e match {
+ case e: Representation with Members =>
+ trans(e)
+ e.members.map(mutateEntities(_)(trans))
+ case e: Representation => trans(e)
+ }
+
+ def relativePath(from: Representation, to: Representation) = {
+ val offset = from match {
+ case _: ValRepresentation | _: DefRepresentation => 1
+ case _ => 0
+ }
+
+ "../" * (from.path.length - offset) +
+ (to match {
+ case r => (to.path :+ to.name).mkString("/")
+ })
+ }
+
+
+ def rootPackages(pkgs: Map[String, PackageRepresentation]): List[PackageRepresentation] = {
+ var currentDepth = Int.MaxValue
+ var packs = List.empty[String]
+
+ for (key <- pkgs.keys) {
+ val keyDepth = key.split("\\.").length
+ packs =
+ if (keyDepth < currentDepth) {
+ currentDepth = keyDepth
+ key :: Nil
+ } else if (keyDepth == currentDepth) {
+ key :: packs
+ } else packs
+ }
+ packs.map(pkgs.apply)
+ }
+}
diff --git a/tastydoc/src/dotty/tastydoc/mdscala.scala b/tastydoc/src/dotty/tastydoc/mdscala.scala
new file mode 100644
index 000000000000..0352d1caf3f6
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/mdscala.scala
@@ -0,0 +1,107 @@
+package dotty.tastydoc
+
+/** Contains function to generate markdown (follows CommonMarkdown specifications)*/
+object Md {
+ /** Form a header
+ *
+ * @param obj Label of the header, usually a String
+ * @param level Header level, 1-6
+ * @return The formed header as a String
+ */
+ def header(obj: Any, level: Int) : String = {
+ require(level <= 6 && level >= 1, "Wrong header level")
+ "#" * level + " " + obj.toString + "\n"
+ }
+
+ /** Form a header of level 1
+ *
+ * @param obj Label of the header, usually a String
+ * @return The formed header as a String
+ */
+ def header1(obj: Any) : String = {
+ header(obj, 1)
+ }
+
+ /** Form a header of level 2
+ *
+ * @param obj Label of the header, usually a String
+ * @return The formed header as a String
+ */
+ def header2(obj: Any) : String = {
+ header(obj, 2)
+ }
+
+ /** Form a header of level 3
+ *
+ * @param obj Label of the header, usually a String
+ * @return The formed header as a String
+ */
+ def header3(obj: Any) : String = {
+ header(obj, 3)
+ }
+
+ /** Form a header of level 4
+ *
+ * @param obj Label of the header, usually a String
+ * @return The formed header as a String
+ */
+ def header4(obj: Any) : String = {
+ header(obj, 4)
+ }
+
+ /** Form a header of level 5
+ *
+ * @param obj Label of the header, usually a String
+ * @return The formed header as a String
+ */
+ def header5(obj: Any) : String = {
+ header(obj, 5)
+ }
+
+ /** Form a header of level 6
+ *
+ * @param obj Label of the header, usually a String
+ * @return The formed header as a String
+ */
+ def header6(obj: Any) : String = {
+ header(obj, 6)
+ }
+
+ /** Form a fenced code block
+ *
+ * @param obj The content of the code block
+ * @param language Specific language for the syntax highlight (default: no language)
+ * @return The formed code block
+ */
+ def codeBlock(obj: Any, language : String = "") : String = {
+ "```" + language + "\n" + obj.toString + "\n```\n"
+ }
+ /** Transform something in bold
+ *
+ * @param obj The content of the code block
+ * @return The object string in bold
+ */
+ def bold(obj: Any) : String = {
+ "**" + obj.toString + "**"
+ }
+
+ /** Transform something in italics
+ *
+ * @param obj The content of the code block
+ * @return The object string in italics
+ */
+ def italics(obj: Any) : String = {
+ "*" + obj.toString + "*"
+ }
+
+ /** Add a link to something
+ *
+ * @param obj The label of the link
+ * @param link The link
+ *
+ * @return The label linking to the desired link
+ */
+ def link(label: Any, link: String): String = {
+ "[" + label.toString + "](" + link + ")"
+ }
+}
\ No newline at end of file
diff --git a/tastydoc/src/dotty/tastydoc/references.scala b/tastydoc/src/dotty/tastydoc/references.scala
new file mode 100644
index 000000000000..2ce09886ed3d
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/references.scala
@@ -0,0 +1,18 @@
+package dotty.tastydoc
+
+object references {
+ sealed trait Reference
+ //Be aware that the label may end with a "$" in case it is referencing an object
+ final case class TypeReference(label: String, path: String, typeParams: List[Reference], hasOwnFile: Boolean = false) extends Reference
+ final case class OrTypeReference(left: Reference, right: Reference) extends Reference
+ final case class AndTypeReference(left: Reference, right: Reference) extends Reference
+ final case class FunctionReference(args: List[Reference], returnValue: Reference, isImplicit: Boolean) extends Reference
+ final case class TupleReference(args: List[Reference]) extends Reference
+ final case class BoundsReference(low: Reference, high: Reference) extends Reference
+ final case class NamedReference(name: String, ref: Reference, isRepeated: Boolean = false) extends Reference
+ final case class ByNameReference(ref: Reference) extends Reference
+ final case class ConstantReference(label: String) extends Reference
+ final case class CompanionReference(label: String, path: String, kind: String) extends Reference
+ final case class RefinedReference(parent: Reference, ls: List[(String, String, Reference)]) extends Reference
+ case object EmptyReference extends Reference
+}
\ No newline at end of file
diff --git a/tastydoc/src/dotty/tastydoc/representations.scala b/tastydoc/src/dotty/tastydoc/representations.scala
new file mode 100644
index 000000000000..97d233958f02
--- /dev/null
+++ b/tastydoc/src/dotty/tastydoc/representations.scala
@@ -0,0 +1,241 @@
+package dotty.tastydoc
+
+import scala.tasty.Reflection
+import scala.annotation.tailrec
+import dotty.tastydoc.comment.Comment
+import dotty.tastydoc.references._
+
+object representations extends TastyExtractor {
+
+ trait Representation {
+ val name : String
+ val path : List[String]
+ def comments(packages: Map[String, EmulatedPackageRepresentation], userDocSyntax: String): Option[Comment]
+ val parentRepresentation: Option[Representation] //Called simply "parent" in dotty-doc
+ val annotations: List[TypeReference]
+ }
+
+ trait Parents {
+ val parents : List[Reference] //Inheritance similar to supertypes in dotty-doc
+ }
+
+ trait Members {
+ def members : List[Representation] //Is a def so we can override with either a var or a val (Needed for EmulatedPackage)
+ }
+
+ trait Modifiers {
+ val modifiers: List[String]
+ val privateWithin: Option[Reference]
+ val protectedWithin: Option[Reference]
+
+ def isPrivate: Boolean = modifiers.contains("private")
+ def isProtected: Boolean = modifiers.contains("protected")
+ def isAbstract: Boolean = modifiers.contains("abstract")
+ }
+
+ trait Companion {
+ val companion: Option[CompanionReference]
+
+ def hasCompanion: Boolean = companion.isDefined //To be consistent with dotty-doc
+ }
+
+ trait ParamList {
+ val list: List[NamedReference]
+ val isImplicit: Boolean
+ }
+
+ trait MultipleParamList {
+ val paramLists: List[ParamList]
+ }
+
+ trait Constructors {
+ val constructors: List[DefRepresentation]
+ }
+
+ trait ReturnValue {
+ val returnValue: Reference
+ }
+
+ trait TypeParams {
+ val typeParams: List[String]
+ }
+
+ /** This contains all the PackageRepresentation representing a single package
+ */
+ class EmulatedPackageRepresentation(val name: String, val path: List[String]) given (mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]) extends Representation with Members {
+ override val parentRepresentation = None
+ override val annotations = Nil
+ override def comments(packages: Map[String, EmulatedPackageRepresentation], userDocSyntax: String) = None
+ var packagesMembers: List[PackageRepresentation] = Nil
+
+ //From the outisde, calling members is seemless and appears like calling members on a PackageRepresentation
+ override def members = {
+ @tailrec
+ def noDuplicates(seenPackages: Set[String], members: List[Representation], acc: List[Representation]): (List[Representation], Set[String]) = members match {
+ case Nil => (acc, seenPackages)
+ case (x: PackageRepresentation)::xs if seenPackages.contains(x.name) => noDuplicates(seenPackages, xs, acc)
+ case (x: PackageRepresentation)::xs => noDuplicates(seenPackages + x.name, xs, mutablePackagesMap((x.path :+ x.name).mkString(".")) :: acc)
+ case x::xs => noDuplicates(seenPackages, xs, x::acc)
+ }
+
+ packagesMembers.foldLeft((List.empty[Representation], Set.empty[String]))((acc, p) => noDuplicates(acc._2, p.members, acc._1))._1
+ }
+ }
+
+ class PackageRepresentation(reflect: Reflection, internal: reflect.PackageClause, override val parentRepresentation: Option[Representation]) given (mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]) extends Representation with Members {
+ import reflect._
+
+ override val (name, path) = extractPackageNameAndPath(internal.pid.show(implicitly[reflect.Context].withoutColors))
+ override val members = internal.stats.map(convertToRepresentation(reflect)(_, Some(this)))
+ override val annotations = extractAnnotations(reflect)(internal.symbol.annots)
+
+ override def comments(packages: Map[String, EmulatedPackageRepresentation], userDocSyntax: String) = extractComments(reflect)(internal.symbol.comment, this)(packages, userDocSyntax)
+ }
+
+ class ImportRepresentation(reflect: Reflection, internal: reflect.Import, override val parentRepresentation: Option[Representation]) given (mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]) extends Representation {
+ import reflect._
+
+ override val name = if (internal.selectors.size > 1){
+ internal.selectors.map(_.toString).mkString("{", ", ", "}")
+ } else {
+ internal.selectors.head.toString
+ }
+ override val path = internal.expr.symbol.show(implicitly[reflect.Context].withoutColors).split("\\.").toList
+ override val annotations = extractAnnotations(reflect)(internal.symbol.annots)
+
+ override def comments(packages: Map[String, EmulatedPackageRepresentation], userDocSyntax: String) = extractComments(reflect)(internal.symbol.comment, this)(packages, userDocSyntax)
+ }
+
+ class ClassRepresentation(reflect: Reflection, internal: reflect.ClassDef, override val parentRepresentation: Option[Representation]) given (mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]) extends Representation with Members with Parents with Modifiers with Companion with Constructors with TypeParams {
+ import reflect._
+
+ override val path = extractPath(reflect)(internal.symbol)
+ override val parents = extractParents(reflect)(internal.parents)
+ override val (modifiers, privateWithin, protectedWithin) = extractModifiers(reflect)(internal.symbol.flags, internal.symbol.privateWithin, internal.symbol.protectedWithin)
+ override val constructors =
+ (convertToRepresentation(reflect)(internal.constructor, Some(this)) ::
+ (internal.body.flatMap{_ match {
+ case reflect.IsDefDef(d@reflect.DefDef(_)) => if(d.name == "") Some(d) else None
+ case _ => None
+ }
+ }.map(convertToRepresentation(reflect)(_, Some(this)))
+ )).flatMap{r => r match {
+ case r: DefRepresentation => Some(r)
+ case _ => None
+ }
+ }
+ override val typeParams = internal.constructor.typeParams.map(x => x.show(implicitly[reflect.Context].withoutColors).stripPrefix("type "))
+ override val annotations = extractAnnotations(reflect)(internal.symbol.annots)
+ var knownSubclasses: List[Reference] = Nil
+
+ val (isCase, isTrait, isObject, kind) = extractKind(reflect)(internal.symbol.flags)
+
+ override val name = internal.name
+
+ override val companion = extractCompanion(reflect)(internal.symbol.companionModule, internal.symbol.companionClass, !isObject)
+ override val members: List[Representation with Modifiers] = extractClassMembers(reflect)(internal.body, internal.symbol, Some(this))
+
+ override def comments(packages: Map[String, EmulatedPackageRepresentation], userDocSyntax: String) = extractComments(reflect)(internal.symbol.comment, this)(packages, userDocSyntax)
+ }
+
+ class DefRepresentation(reflect: Reflection, internal: reflect.DefDef, override val parentRepresentation: Option[Representation]) given (mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]) extends Representation with Modifiers with TypeParams with MultipleParamList with ReturnValue {
+ import reflect._
+
+ override val name = internal.name
+ override val path = extractPath(reflect)(internal.symbol)
+ override val (modifiers, privateWithin, protectedWithin) = extractModifiers(reflect)(internal.symbol.flags, internal.symbol.privateWithin, internal.symbol.protectedWithin)
+ override val typeParams = internal.typeParams.map(x => x.show(implicitly[reflect.Context].withoutColors).stripPrefix("type "))
+
+ override val paramLists = internal.paramss.map{p =>
+ new ParamList {
+ override val list = p.map(x => NamedReference(x.name, convertTypeToReference(reflect)(x.tpt.tpe)))
+ override val isImplicit = if(p.nonEmpty) p.head.symbol.flags.is(Flags.Implicit) else false
+ }
+ }
+ override val returnValue = convertTypeToReference(reflect)(internal.returnTpt.tpe)
+ override val annotations = extractAnnotations(reflect)(internal.symbol.annots)
+ override def comments(packages: Map[String, EmulatedPackageRepresentation], userDocSyntax: String) = extractComments(reflect)(internal.symbol.comment, this)(packages, userDocSyntax)
+ }
+
+ class ValRepresentation(reflect: Reflection, internal: reflect.ValDef, override val parentRepresentation: Option[Representation]) given (mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]) extends Representation with Modifiers with ReturnValue {
+ import reflect._
+
+ override val name = internal.name
+ override val path = extractPath(reflect)(internal.symbol)
+ override val (modifiers, privateWithin, protectedWithin) = extractModifiers(reflect)(internal.symbol.flags, internal.symbol.privateWithin, internal.symbol.protectedWithin)
+ override val returnValue = convertTypeToReference(reflect)(internal.tpt.tpe)
+ override val annotations = extractAnnotations(reflect)(internal.symbol.annots)
+ val isVar: Boolean = internal.symbol.flags.is(Flags.Mutable)
+
+ override def comments(packages: Map[String, EmulatedPackageRepresentation], userDocSyntax: String) = extractComments(reflect)(internal.symbol.comment, this)(packages, userDocSyntax)
+ }
+
+ class TypeRepresentation(reflect: Reflection, internal: reflect.TypeDef, override val parentRepresentation: Option[Representation]) given (mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]) extends Representation with Modifiers with TypeParams {
+ import reflect._
+
+ override val name = internal.name
+ override val path = extractPath(reflect)(internal.symbol)
+ override val (modifiers, privateWithin, protectedWithin) = extractModifiers(reflect)(internal.symbol.flags, internal.symbol.privateWithin, internal.symbol.protectedWithin)
+ override val typeParams = Nil
+ override val annotations = extractAnnotations(reflect)(internal.symbol.annots)
+ val alias: Option[Reference] = internal.rhs match{
+ case reflect.IsTypeBoundsTree(t) => Some(convertTypeOrBoundsToReference(reflect)(t.tpe))
+ case reflect.IsTypeTree(t) => Some(convertTypeOrBoundsToReference(reflect)(t.tpe.asInstanceOf[reflect.TypeOrBounds]))
+ case _ => None
+ }
+ override def isAbstract: Boolean = !alias.isDefined
+ override def comments(packages: Map[String, EmulatedPackageRepresentation], userDocSyntax: String) = extractComments(reflect)(internal.symbol.comment, this)(packages, userDocSyntax)
+ }
+
+ def convertToRepresentation(reflect: Reflection)(tree: reflect.Tree, parentRepresentation: Option[Representation]) given (mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]): Representation = {
+ import reflect._
+
+ tree match {
+ case reflect.IsPackageClause(t@reflect.PackageClause(_)) =>
+ val noColorPid = t.pid.symbol.show(implicitly[reflect.Context].withoutColors)
+ val emulatedPackage = mutablePackagesMap.get(noColorPid) match {
+ case Some(x) => x
+ case None =>
+ val (name, path) = extractPackageNameAndPath(noColorPid)
+ val x = new EmulatedPackageRepresentation(name, path)
+ mutablePackagesMap += ((noColorPid, x))
+ x
+ }
+ val r = new PackageRepresentation(reflect, t, parentRepresentation)
+ emulatedPackage.packagesMembers = r :: emulatedPackage.packagesMembers
+ r
+
+ case reflect.IsImport(t@reflect.Import(_)) => new ImportRepresentation(reflect, t, parentRepresentation)
+
+ case reflect.IsClassDef(t@reflect.ClassDef(_)) => new ClassRepresentation(reflect, t, parentRepresentation)
+
+ case reflect.IsDefDef(t@reflect.DefDef(_)) => new DefRepresentation(reflect, t, parentRepresentation)
+
+ case reflect.IsValDef(t@reflect.ValDef(_)) => new ValRepresentation(reflect, t, parentRepresentation)
+
+ case reflect.IsTypeDef(t@reflect.TypeDef(_)) => new TypeRepresentation(reflect, t, parentRepresentation)
+
+ case _ => throw new Exception("Tree match error in conversion to representation. Please open an issue. " + tree)
+ }}
+
+ def setSubClasses(mutablePackagesMap: scala.collection.mutable.HashMap[String, EmulatedPackageRepresentation]): Unit = {
+ def innerLogic(representation: Representation): Unit = representation match {
+ case r: ClassRepresentation =>
+ r.parents.foreach{_ match {
+ case ref@TypeReference(label, path, _, _) => mutablePackagesMap.get(path.replaceFirst("/", "").replaceAll("/", ".")) match {
+ case Some(p) =>
+ p.members.filter(_.name == label).foreach{_ match {
+ case parent: ClassRepresentation => parent.knownSubclasses = TypeReference(r.name, r.path.mkString("/", "/", ""), Nil, true) :: parent.knownSubclasses
+ case _ =>
+ }}
+ case None =>
+ }
+ case _ =>
+ }}
+ case r: Representation with Members => r.members.foreach(innerLogic)
+ case _ =>
+ }
+
+ mutablePackagesMap.foreach((_, v) => innerLogic(v))
+ }
+}
\ No newline at end of file
diff --git a/tastydoc/test/dotty/tastydoc/Tests.scala b/tastydoc/test/dotty/tastydoc/Tests.scala
new file mode 100644
index 000000000000..7c7295e433a3
--- /dev/null
+++ b/tastydoc/test/dotty/tastydoc/Tests.scala
@@ -0,0 +1,77 @@
+package dotty.tastydoc
+
+import scala.tasty.Reflection
+import scala.tasty.file._
+import scala.collection.mutable.HashMap
+
+import org.junit.Test
+import org.junit.Assert._
+import java.nio.file._
+import scala.collection.JavaConverters._
+import java.io.File
+import scala.tasty.Reflection
+import scala.tasty.file.TastyConsumer
+import java.lang.reflect.InvocationTargetException
+
+class Tests {
+ @Test def testDocumentation(): Unit = {
+ Main.main(Array(
+ "--classpath",
+ "tastydoc/out/bootstrap/dotty-tastydoc-input/scala-0.17/classes",
+ "--syntax",
+ "wiki",
+ //"markdown",
+ "--packagestolink",
+ "example.*",
+ //"scala.*",
+ "-i",
+ "example.level2.Documentation",
+ "example.level2.ClassExtendingDocumentation",
+ "example.DocumentationInheritance",
+ "example.ReturnTypeClass",
+ "example.level2.SameLevelTypeLinking",
+ "example.ReturnObjectWithType",
+ "example.level2.TraitWithCompanion",
+ "example.level2.level3.level4.ClassLevel4",
+ "example.UserDocLinkingClass"
+ ))
+ }
+ @Test def testDotty(): Unit = {
+ Main.main(Array(
+ "--classpath",
+ "tastydoc/dotty-0.16.0-RC3/lib",
+ "--syntax",
+ "wiki",
+ "--packagestolink",
+ "dotty.*",
+ "scala.annotation.*",
+ "scala.compiletime.*",
+ "scala.implicits.*",
+ "scala.internal.*",
+ "scala.quoted.*",
+ "scala.reflect.*",
+ "scala.runtime.*",
+ "scala.tasty.*",
+ "scala.testing.*",
+ "scalaShadowing.*",
+ //Individual files
+ "scala.\\$times\\$colon*",
+ "scala.Conversion*",
+ "scala.Enum*",
+ "scala.Eql*",
+ "scala.forceInline*",
+ "scala.FunctionXXL*",
+ "scala.IArray*",
+ "scala.NonEmptyTuple*",
+ "scala.Product0*",
+ "scala.Selectable*",
+ "scala.Tuple*",
+ "scala.TupleXXL*",
+ "scala.ValueOf*",
+ "-d",
+ "dotty",
+ "scala",
+ "scalaShadowing"
+ ))
+ }
+}
\ No newline at end of file