Put precise types in extractor arguments

nicolasstucki · nicolasstucki · commit 603d7533c5cb · 2018-04-24T16:58:06.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/tasty/internal/PolyType.scala b/compiler/src/dotty/tools/dotc/tasty/internal/PolyType.scala
@@ -21,7 +21,7 @@ object PolyType {
   private[tasty] class Impl(val meth: Types.PolyType)(implicit val ctx: Context) extends types.PolyType {
     override def toString: String = {
       import Toolbox.extractor
-      val types.MethodType(paramNames, paramTypes, resType) = this
+      val types.PolyType(paramNames, paramTypes, resType) = this
       s"PolyType($paramNames, $paramTypes, $resType)"
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/tasty/internal/TypeLambda.scala b/compiler/src/dotty/tools/dotc/tasty/internal/TypeLambda.scala
@@ -21,7 +21,7 @@ object TypeLambda {
   private[tasty] class Impl(val meth: Types.TypeLambda)(implicit val ctx: Context) extends types.TypeLambda {
     override def toString: String = {
       import Toolbox.extractor
-      val types.MethodType(paramNames, paramTypes, resType) = this
+      val types.TypeLambda(paramNames, paramTypes, resType) = this
       s"TypeLambda($paramNames, $paramTypes, $resType)"
     }
   }
diff --git a/library/src/scala/tasty/names/SignedName.scala b/library/src/scala/tasty/names/SignedName.scala
@@ -6,5 +6,5 @@ trait SignedName extends PossiblySignedName
 
 object SignedName {
   type Data = (TermName, TypeName, List[TypeName])
-  def unapply(arg: PossiblySignedName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySignedName(arg)
+  def unapply(arg: SignedName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySignedName(arg)
 }
diff --git a/library/src/scala/tasty/names/TypeName.scala b/library/src/scala/tasty/names/TypeName.scala
@@ -6,5 +6,5 @@ trait TypeName extends Name
 
 object TypeName {
   type Data = TermName
-  def unapply(arg: Name)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeName(arg)
+  def unapply(arg: TypeName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeName(arg)
 }
diff --git a/library/src/scala/tasty/names/package.scala b/library/src/scala/tasty/names/package.scala
@@ -6,49 +6,49 @@ package object names {
 
   object Simple {
     type Data = String
-    def unapply(arg: Name /* | PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySimple(arg)
+    def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySimple(arg)
   }
 
   // s"$prefix.$name"
   object Qualified {
     type Data = (TermName, String)
-    def unapply(arg: Name /* | PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyQualified(arg)
+    def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyQualified(arg)
   }
 
   // s"$methodName${"$default$"}${idx+1}"
   object DefaultGetter {
     type Data = (TermName, String)
-    def unapply(arg: Name /* | PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyDefaultGetter(arg)
+    def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyDefaultGetter(arg)
   }
 
   // s"${if (covariant) "+" else "-"}$underlying"
   object Variant {
     type Data = (TermName, Boolean)
-    def unapply(arg: Name /* | PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyVariant(arg)
+    def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyVariant(arg)
   }
 
   // s"${"super$"}$underlying"
   object SuperAccessor {
     type Data = TermName
-    def unapply(arg: Name /* | PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySuperAccessor(arg)
+    def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySuperAccessor(arg)
   }
 
   // s"${"protected$"}$underlying"
   object ProtectedAccessor {
     type Data = TermName
-    def unapply(arg: Name /* | PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyProtectedAccessor(arg)
+    def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyProtectedAccessor(arg)
   }
 
   // s"${"protected$set"}$underlying"
   object ProtectedSetter {
     type Data = TermName
-    def unapply(arg: Name /* | PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyProtectedSetter(arg)
+    def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyProtectedSetter(arg)
   }
 
   // s"$underlying${"$"}"
   object ObjectClass {
     type Data = TermName
-    def unapply(arg: Name /* | PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyObjectClass(arg)
+    def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyObjectClass(arg)
   }
 
 }
diff --git a/library/src/scala/tasty/trees/CaseDef.scala b/library/src/scala/tasty/trees/CaseDef.scala
@@ -6,5 +6,5 @@ trait CaseDef extends Tree
 
 object CaseDef {
   type Data = (Pattern, Option[Term], Term)
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyCaseDef(arg)
+  def unapply(arg: CaseDef)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyCaseDef(arg)
 }
diff --git a/library/src/scala/tasty/trees/ClassDef.scala b/library/src/scala/tasty/trees/ClassDef.scala
@@ -9,5 +9,5 @@ trait ClassDef extends Definition
 object ClassDef {
 
   type Data = (names.TypeName, DefDef, List[Tree] /* List[Term | TypeTree] */,  Option[ValDef], List[Statement], List[Modifier])
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyClassDef(arg)
+  def unapply(arg: ClassDef)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyClassDef(arg)
 }
diff --git a/library/src/scala/tasty/trees/DefDef.scala b/library/src/scala/tasty/trees/DefDef.scala
@@ -8,5 +8,5 @@ trait DefDef extends Definition
 
 object DefDef {
   type Data = (names.TermName, List[TypeDef],  List[List[ValDef]], TypeTree, Option[Term], List[Modifier])
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyDefDef(arg)
+  def unapply(arg: DefDef)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyDefDef(arg)
 }
diff --git a/library/src/scala/tasty/trees/Import.scala b/library/src/scala/tasty/trees/Import.scala
@@ -7,5 +7,5 @@ trait Import extends Statement
 
 object Import {
   type Data = (Term, List[ImportSelector])
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyImport(arg)
+  def unapply(arg: Import)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyImport(arg)
 }
diff --git a/library/src/scala/tasty/trees/PackageClause.scala b/library/src/scala/tasty/trees/PackageClause.scala
@@ -6,5 +6,5 @@ trait PackageClause extends TopLevelStatement
 
 object PackageClause {
   type Data = (Term, List[TopLevelStatement])
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyPackageClause(arg)
+  def unapply(arg: PackageClause)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyPackageClause(arg)
 }
diff --git a/library/src/scala/tasty/trees/PackageDef.scala b/library/src/scala/tasty/trees/PackageDef.scala
@@ -7,5 +7,5 @@ trait PackageDef extends Definition
 
 object PackageDef {
   type Data = (names.Name, List[Statement])
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyPackageDef(arg)
+  def unapply(arg: PackageDef)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyPackageDef(arg)
 }
diff --git a/library/src/scala/tasty/trees/Pattern.scala b/library/src/scala/tasty/trees/Pattern.scala
@@ -10,25 +10,25 @@ trait Pattern extends Tree {
 
 object Value {
   type Data = Term
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyValue(arg)
+  def unapply(arg: Pattern)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyValue(arg)
 }
 
 object Bind {
   type Data = (names.TermName, Pattern)
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyBind(arg)
+  def unapply(arg: Pattern)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyBind(arg)
 }
 
 object Unapply {
   type Data = (Term, List[Term], List[Pattern])
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyUnapply(arg)
+  def unapply(arg: Pattern)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyUnapply(arg)
 }
 
 object Alternative {
   type Data = List[Pattern]
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyAlternative(arg)
+  def unapply(arg: Pattern)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyAlternative(arg)
 }
 
 object TypeTest {
   type Data = TypeTree
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeTest(arg)
+  def unapply(arg: Pattern)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeTest(arg)
 }
diff --git a/library/src/scala/tasty/trees/TypeBoundsTree.scala b/library/src/scala/tasty/trees/TypeBoundsTree.scala
@@ -9,5 +9,5 @@ trait TypeBoundsTree extends Tree {
 
 object TypeBoundsTree {
   type Data = (TypeTree, TypeTree)
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeBoundsTree(arg)
+  def unapply(arg: TypeBoundsTree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeBoundsTree(arg)
 }
diff --git a/library/src/scala/tasty/trees/TypeDef.scala b/library/src/scala/tasty/trees/TypeDef.scala
@@ -8,5 +8,5 @@ trait TypeDef extends Definition
 
 object TypeDef {
   type Data = (names.TypeName, Tree /* Type | TypeBounds */, List[Modifier])
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeDef(arg)
+  def unapply(arg: TypeDef)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeDef(arg)
 }
diff --git a/library/src/scala/tasty/trees/ValDef.scala b/library/src/scala/tasty/trees/ValDef.scala
@@ -8,5 +8,5 @@ trait ValDef extends Definition
 
 object ValDef {
   type Data = (names.TermName, TypeTree, Option[Term], List[Modifier])
-  def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyValDef(arg)
+  def unapply(arg: ValDef)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyValDef(arg)
 }
diff --git a/library/src/scala/tasty/trees/package.scala b/library/src/scala/tasty/trees/package.scala
@@ -8,27 +8,27 @@ package object trees {
 
   object Ident {
     type Data = (names.TermName)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyIdent(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyIdent(arg)
   }
 
   object Select {
     type Data = (Term, names.PossiblySignedName)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySelect(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySelect(arg)
   }
 
   object Literal {
     type Data = constants.Constant
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyLiteral(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyLiteral(arg)
   }
 
   object This {
     type Data = Option[Id]
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyThis(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyThis(arg)
   }
 
   object New {
     type Data = TypeTree
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyNew(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyNew(arg)
   }
 
   object NamedArg {
@@ -38,72 +38,72 @@ package object trees {
 
   object Apply {
     type Data = (Term, List[Term])
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyApply(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyApply(arg)
   }
 
   object TypeApply {
     type Data = (Term, List[TypeTree])
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeApply(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeApply(arg)
   }
 
   object Super {
     type Data = (Term, Option[Id])
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySuper(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySuper(arg)
   }
 
   object Typed {
     type Data = (Term, TypeTree)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTyped(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTyped(arg)
   }
 
   object Assign {
     type Data = (Term, Term)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyAssign(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyAssign(arg)
   }
 
   object Block {
     type Data = (List[Statement], Term)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyBlock(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyBlock(arg)
   }
 
   object Inlined {
     type Data = (Term, List[Definition], Term)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyInlined(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyInlined(arg)
   }
 
   object Lambda {
     type Data = (Term, Option[TypeTree])
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyLambda(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyLambda(arg)
   }
 
   object If {
     type Data = (Term, Term, Term)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyIf(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyIf(arg)
   }
 
   object Match {
     type Data = (Term, List[CaseDef])
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyMatch(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyMatch(arg)
   }
 
   object Try {
     type Data = (Term, List[CaseDef], Option[Term])
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTry(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTry(arg)
   }
 
   object Return {
     type Data = Term
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyReturn(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyReturn(arg)
   }
 
   object Repeated {
     type Data = List[Term]
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyRepeated(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyRepeated(arg)
   }
 
   object SelectOuter {
     type Data = (Term, Int, types.Type)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySelectOuter(arg)
+    def unapply(arg: Term)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySelectOuter(arg)
   }
 
   // Type trees
@@ -114,47 +114,47 @@ package object trees {
 
   object TypeIdent {
     type Data = names.TypeName
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeIdent(arg)
+    def unapply(arg: TypeTree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeIdent(arg)
   }
 
   object TypeSelect {
     type Data = (Term, names.TypeName)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeSelect(arg)
+    def unapply(arg: TypeTree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeSelect(arg)
   }
 
   object Singleton {
     type Data = Term
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySingleton(arg)
+    def unapply(arg: TypeTree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySingleton(arg)
   }
 
   object Refined {
     type Data = (TypeTree, List[Definition])
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyRefined(arg)
+    def unapply(arg: TypeTree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyRefined(arg)
   }
 
   object Applied {
     type Data = (TypeTree, List[TypeTree])
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyApplied(arg)
+    def unapply(arg: TypeTree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyApplied(arg)
   }
 
   object Annotated {
     type Data = (TypeTree, Term)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyAnnotated(arg)
+    def unapply(arg: TypeTree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyAnnotated(arg)
   }
 
   object And {
     type Data = (TypeTree, TypeTree)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyAnd(arg)
+    def unapply(arg: TypeTree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyAnd(arg)
   }
 
   object Or {
     type Data = (TypeTree, TypeTree)
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyOr(arg)
+    def unapply(arg: TypeTree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyOr(arg)
   }
 
   object ByName {
     type Data = TypeTree
-    def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyByName(arg)
+    def unapply(arg: TypeTree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyByName(arg)
   }
 
 }
diff --git a/library/src/scala/tasty/types/LambdaType.scala b/library/src/scala/tasty/types/LambdaType.scala
@@ -11,17 +11,17 @@ trait MethodType extends LambdaType[names.TermName, Type] {
 }
 object MethodType {
   type Data = (List[names.TermName], List[Type], Type)
-  def unapply(arg: MaybeType)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyMethodType(arg)
+  def unapply(arg: MethodType)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyMethodType(arg)
 }
 
 trait PolyType extends LambdaType[names.TypeName, TypeBounds]
 object PolyType {
   type Data = (List[names.TypeName], List[TypeBounds], Type)
-  def unapply(arg: MaybeType)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyPolyType(arg)
+  def unapply(arg: PolyType)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyPolyType(arg)
 }
 
 trait TypeLambda extends LambdaType[names.TypeName, TypeBounds]
 object TypeLambda {
   type Data = (List[names.TypeName], List[TypeBounds], Type)
-  def unapply(arg: MaybeType)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeLambda(arg)
+  def unapply(arg: TypeLambda)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeLambda(arg)
 }
diff --git a/library/src/scala/tasty/types/RecursiveType.scala b/library/src/scala/tasty/types/RecursiveType.scala
@@ -6,5 +6,5 @@ trait RecursiveType extends Type
 
 object RecursiveType {
   type Data = Type
-  def unapply(arg: MaybeType)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyRecursiveType(arg)
+  def unapply(arg: RecursiveType)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyRecursiveType(arg)
 }
diff --git a/library/src/scala/tasty/types/TypeBounds.scala b/library/src/scala/tasty/types/TypeBounds.scala
@@ -6,5 +6,5 @@ trait TypeBounds extends MaybeType
 
 object TypeBounds {
   type Data = (Type, Type)
-  def unapply(arg: MaybeType)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeBounds(arg)
+  def unapply(arg: TypeBounds)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeBounds(arg)
 }
diff --git a/library/src/scala/tasty/types/package.scala b/library/src/scala/tasty/types/package.scala
diff --git a/tests/run-with-compiler/tasty-extractors-owners.scala b/tests/run-with-compiler/tasty-extractors-owners.scala

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ object PolyType {`
`21`	`21`	`private[tasty] class Impl(val meth: Types.PolyType)(implicit val ctx: Context) extends types.PolyType {`
`22`	`22`	`override def toString: String = {`
`23`	`23`	`import Toolbox.extractor`
`24`		`- val types.MethodType(paramNames, paramTypes, resType) = this`
	`24`	`+ val types.PolyType(paramNames, paramTypes, resType) = this`
`25`	`25`	`s"PolyType($paramNames, $paramTypes, $resType)"`
`26`	`26`	`}`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ object TypeLambda {`
`21`	`21`	`private[tasty] class Impl(val meth: Types.TypeLambda)(implicit val ctx: Context) extends types.TypeLambda {`
`22`	`22`	`override def toString: String = {`
`23`	`23`	`import Toolbox.extractor`
`24`		`- val types.MethodType(paramNames, paramTypes, resType) = this`
	`24`	`+ val types.TypeLambda(paramNames, paramTypes, resType) = this`
`25`	`25`	`s"TypeLambda($paramNames, $paramTypes, $resType)"`
`26`	`26`	`}`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,5 +6,5 @@ trait SignedName extends PossiblySignedName`
`6`	`6`
`7`	`7`	`object SignedName {`
`8`	`8`	`type Data = (TermName, TypeName, List[TypeName])`
`9`		`- def unapply(arg: PossiblySignedName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySignedName(arg)`
	`9`	`+ def unapply(arg: SignedName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySignedName(arg)`
`10`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,5 +6,5 @@ trait TypeName extends Name`
`6`	`6`
`7`	`7`	`object TypeName {`
`8`	`8`	`type Data = TermName`
`9`		`- def unapply(arg: Name)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeName(arg)`
	`9`	`+ def unapply(arg: TypeName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyTypeName(arg)`
`10`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,49 +6,49 @@ package object names {`
`6`	`6`
`7`	`7`	`object Simple {`
`8`	`8`	`type Data = String`
`9`		`- def unapply(arg: Name /* \| PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySimple(arg)`
	`9`	`+ def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySimple(arg)`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`// s"$prefix.$name"`
`13`	`13`	`object Qualified {`
`14`	`14`	`type Data = (TermName, String)`
`15`		`- def unapply(arg: Name /* \| PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyQualified(arg)`
	`15`	`+ def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyQualified(arg)`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`// s"$methodName${"$default$"}${idx+1}"`
`19`	`19`	`object DefaultGetter {`
`20`	`20`	`type Data = (TermName, String)`
`21`		`- def unapply(arg: Name /* \| PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyDefaultGetter(arg)`
	`21`	`+ def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyDefaultGetter(arg)`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`// s"${if (covariant) "+" else "-"}$underlying"`
`25`	`25`	`object Variant {`
`26`	`26`	`type Data = (TermName, Boolean)`
`27`		`- def unapply(arg: Name /* \| PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyVariant(arg)`
	`27`	`+ def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyVariant(arg)`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`// s"${"super$"}$underlying"`
`31`	`31`	`object SuperAccessor {`
`32`	`32`	`type Data = TermName`
`33`		`- def unapply(arg: Name /* \| PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySuperAccessor(arg)`
	`33`	`+ def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplySuperAccessor(arg)`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`// s"${"protected$"}$underlying"`
`37`	`37`	`object ProtectedAccessor {`
`38`	`38`	`type Data = TermName`
`39`		`- def unapply(arg: Name /* \| PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyProtectedAccessor(arg)`
	`39`	`+ def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyProtectedAccessor(arg)`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`// s"${"protected$set"}$underlying"`
`43`	`43`	`object ProtectedSetter {`
`44`	`44`	`type Data = TermName`
`45`		`- def unapply(arg: Name /* \| PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyProtectedSetter(arg)`
	`45`	`+ def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyProtectedSetter(arg)`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`// s"$underlying${"$"}"`
`49`	`49`	`object ObjectClass {`
`50`	`50`	`type Data = TermName`
`51`		`- def unapply(arg: Name /* \| PossiblySigned */)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyObjectClass(arg)`
	`51`	`+ def unapply(arg: TermName)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyObjectClass(arg)`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,5 +6,5 @@ trait CaseDef extends Tree`
`6`	`6`
`7`	`7`	`object CaseDef {`
`8`	`8`	`type Data = (Pattern, Option[Term], Term)`
`9`		`- def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyCaseDef(arg)`
	`9`	`+ def unapply(arg: CaseDef)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyCaseDef(arg)`
`10`	`10`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,5 @@ trait ClassDef extends Definition`
`9`	`9`	`object ClassDef {`
`10`	`10`
`11`	`11`	`type Data = (names.TypeName, DefDef, List[Tree] /* List[Term \| TypeTree] */, Option[ValDef], List[Statement], List[Modifier])`
`12`		`- def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyClassDef(arg)`
	`12`	`+ def unapply(arg: ClassDef)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyClassDef(arg)`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,5 +8,5 @@ trait DefDef extends Definition`
`8`	`8`
`9`	`9`	`object DefDef {`
`10`	`10`	`type Data = (names.TermName, List[TypeDef], List[List[ValDef]], TypeTree, Option[Term], List[Modifier])`
`11`		`- def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyDefDef(arg)`
	`11`	`+ def unapply(arg: DefDef)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyDefDef(arg)`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,5 +7,5 @@ trait Import extends Statement`
`7`	`7`
`8`	`8`	`object Import {`
`9`	`9`	`type Data = (Term, List[ImportSelector])`
`10`		`- def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyImport(arg)`
	`10`	`+ def unapply(arg: Import)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyImport(arg)`
`11`	`11`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,5 +6,5 @@ trait PackageClause extends TopLevelStatement`
`6`	`6`
`7`	`7`	`object PackageClause {`
`8`	`8`	`type Data = (Term, List[TopLevelStatement])`
`9`		`- def unapply(arg: Tree)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyPackageClause(arg)`
	`9`	`+ def unapply(arg: PackageClause)(implicit toolbox: Toolbox): Option[Data] = toolbox.unapplyPackageClause(arg)`
`10`	`10`	`}`