Always use Module suffix for abstract modules in TASTy Reflect

compiler/src/dotty/tools/dotc/tastyreflect/CaseDefOpsImpl.scala

@@ -9,7 +9,7 @@ trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with CoreImpl with H
     def rhs(implicit ctx: Context): Term = caseDef.body
   }
 
-  object CaseDef extends CaseDefExtractor {
+  object CaseDef extends CaseDefModule {
     def unapply(x: CaseDef): Some[(Pattern, Option[Term], Term)] = Some(x.pat, optional(x.guard), x.body)
   }
 
@@ -18,7 +18,7 @@ trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with CoreImpl with H
     def rhs(implicit ctx: Context): Term = caseDef.body
   }
 
-  object TypeCaseDef extends TypeCaseDefExtractor {
+  object TypeCaseDef extends TypeCaseDefModule {
     def unapply(x: TypeCaseDef): Some[(TypeTree, TypeTree)] = Some((x.pat, x.body))
   }
 }

compiler/src/dotty/tools/dotc/tastyreflect/ConstantOpsImpl.scala

@@ -11,85 +11,85 @@ trait ConstantOpsImpl extends scala.tasty.reflect.ConstantOps with CoreImpl {
 
   object Constant extends ConstantModule {
 
-    object Unit extends UnitExtractor {
+    object Unit extends UnitModule {
       def unapply(x: Constant): Boolean = x.tag == Constants.UnitTag
     }
 
-    object Null extends NullExtractor {
+    object Null extends NullModule {
       def unapply(x: Constant): Boolean = x.tag == Constants.NullTag
     }
 
-    object Boolean extends BooleanExtractor {
+    object Boolean extends BooleanModule {
       def unapply(x: Constant): Option[Boolean] = x match {
         case x: Constants.Constant if x.tag == Constants.BooleanTag => Some(x.booleanValue)
         case _ => None
       }
     }
 
-    object Byte extends ByteExtractor {
+    object Byte extends ByteModule {
       def unapply(x: Constant): Option[Byte] = x match {
         case x: Constants.Constant if x.tag == Constants.ByteTag => Some(x.byteValue)
         case _ => None
       }
     }
 
-    object Short extends ShortExtractor {
+    object Short extends ShortModule {
       def unapply(x: Constant): Option[Short] = x match {
         case x: Constants.Constant if x.tag == Constants.ShortTag => Some(x.shortValue)
         case _ => None
       }
     }
 
-    object Char extends CharExtractor {
+    object Char extends CharModule {
       def unapply(x: Constant): Option[Char] = x match {
         case x: Constants.Constant if x.tag == Constants.CharTag => Some(x.charValue)
         case _ => None
       }
     }
 
-    object Int extends IntExtractor {
+    object Int extends IntModule {
       def unapply(x: Constant): Option[Int] = x match {
         case x: Constants.Constant if x.tag == Constants.IntTag => Some(x.intValue)
         case _ => None
       }
     }
 
-    object Long extends LongExtractor {
+    object Long extends LongModule {
       def unapply(x: Constant): Option[Long] = x match {
         case x: Constants.Constant if x.tag == Constants.LongTag => Some(x.longValue)
         case _ => None
       }
     }
 
-    object Float extends FloatExtractor {
+    object Float extends FloatModule {
       def unapply(x: Constant): Option[Float] = x match {
         case x: Constants.Constant if x.tag == Constants.FloatTag => Some(x.floatValue)
         case _ => None
       }
     }
 
-    object Double extends DoubleExtractor {
+    object Double extends DoubleModule {
       def unapply(x: Constant): Option[Double] = x match {
         case x: Constants.Constant if x.tag == Constants.DoubleTag => Some(x.doubleValue)
         case _ => None
       }
     }
 
-    object String extends StringExtractor {
+    object String extends StringModule {
       def unapply(x: Constant): Option[String] = x match {
         case x: Constants.Constant if x.tag == Constants.StringTag => Some(x.stringValue)
         case _ => None
       }
     }
 
-    object ClassTag extends ClassTagExtractor {
+    object ClassTag extends ClassTagModule {
       def unapply(x: Constant): Option[Type] = x match {
         case x: Constants.Constant if x.tag == Constants.ClazzTag => Some(x.typeValue)
         case _ => None
       }
     }
 
-    object Symbol extends SymbolExtractor {
+    object Symbol extends SymbolModule {
       def unapply(x: Constant): Option[scala.Symbol] = x match {
         case x: Constants.Constant if x.tag == Constants.ScalaSymbolTag => Some(x.scalaSymbolValue)
         case _ => None

compiler/src/dotty/tools/dotc/tastyreflect/IdOpsImpl.scala

@@ -9,7 +9,7 @@ trait IdOpsImpl extends scala.tasty.reflect.IdOps with CoreImpl {
     def name(implicit ctx: Context): String = id.name.toString
   }
 
-  object Id extends IdExtractor {
+  object Id extends IdModule {
     def unapply(id: Id): Option[String] = Some(id.name.toString)
   }
 

compiler/src/dotty/tools/dotc/tastyreflect/ImportSelectorOpsImpl.scala

@@ -5,21 +5,21 @@ import dotty.tools.dotc.core.StdNames.nme
 
 trait ImportSelectorOpsImpl extends scala.tasty.reflect.ImportSelectorOps with CoreImpl {
 
-  object SimpleSelector extends SimpleSelectorExtractor {
+  object SimpleSelector extends SimpleSelectorModule {
     def unapply(x: ImportSelector)(implicit ctx: Context): Option[Id] = x match {
       case x: untpd.Ident => Some(x)
       case _ => None
     }
   }
 
-  object RenameSelector extends RenameSelectorExtractor {
+  object RenameSelector extends RenameSelectorModule {
     def unapply(x: ImportSelector)(implicit ctx: Context): Option[(Id, Id)] = x match {
       case Trees.Thicket((id1: untpd.Ident) :: (id2: untpd.Ident) :: Nil) if id2.name != nme.WILDCARD => Some(id1, id2)
       case _ => None
     }
   }
 
-  object OmitSelector extends OmitSelectorExtractor {
+  object OmitSelector extends OmitSelectorModule {
     def unapply(x: ImportSelector)(implicit ctx: Context): Option[Id] = x match {
       case Trees.Thicket((id: untpd.Ident) :: Trees.Ident(nme.WILDCARD) :: Nil) => Some(id)
       case _ => None

compiler/src/dotty/tools/dotc/tastyreflect/PatternOpsImpl.scala

@@ -14,7 +14,7 @@ trait PatternOpsImpl extends scala.tasty.reflect.PatternOps with CoreImpl {
 
   object Pattern extends PatternModule {
 
-    object Value extends ValueExtractor {
+    object Value extends ValueModule {
       def unapply(x: Pattern)(implicit ctx: Context): Option[Term] = x match {
         case lit: tpd.Literal => Some(lit)
         case ref: tpd.RefTree if ref.isTerm => Some(ref)
@@ -23,14 +23,14 @@ trait PatternOpsImpl extends scala.tasty.reflect.PatternOps with CoreImpl {
       }
     }
 
-    object Bind extends BindExtractor {
+    object Bind extends BindModule {
       def unapply(x: Pattern)(implicit ctx: Context): Option[(String, Pattern)] = x match {
         case x: tpd.Bind if x.name.isTermName => Some(x.name.toString, x.body)
         case _ => None
       }
     }
 
-    object Unapply extends UnapplyExtractor {
+    object Unapply extends UnapplyModule {
       def unapply(x: Pattern)(implicit ctx: Context): Option[(Term, List[Term], List[Pattern])] = x match {
         case Trees.UnApply(fun, implicits, patterns) => Some((fun, implicits, effectivePatterns(patterns)))
         case Trees.Typed(Trees.UnApply(fun, implicits, patterns), _) => Some((fun, implicits, effectivePatterns(patterns)))
@@ -42,14 +42,14 @@ trait PatternOpsImpl extends scala.tasty.reflect.PatternOps with CoreImpl {
       }
     }
 
-    object Alternative extends AlternativeExtractor {
+    object Alternative extends AlternativeModule {
       def unapply(x: Pattern)(implicit ctx: Context): Option[List[Pattern]] = x match {
         case x: tpd.Alternative => Some(x.trees)
         case _ => None
       }
     }
 
-    object TypeTest extends TypeTestExtractor {
+    object TypeTest extends TypeTestModule {
       def unapply(x: Pattern)(implicit ctx: Context): Option[TypeTree] = x match {
         case Trees.Typed(Trees.UnApply(_, _, _), _) => None
         case Trees.Typed(_, tpt) => Some(tpt)

compiler/src/dotty/tools/dotc/tastyreflect/SignatureOpsImpl.scala

@@ -2,7 +2,7 @@ package dotty.tools.dotc.tastyreflect
 
 trait SignatureOpsImpl extends scala.tasty.reflect.SignatureOps with CoreImpl {
 
-  object Signature extends SignatureExtractor {
+  object Signature extends SignatureModule {
     def unapply(x: Signature)(implicit ctx: Context): Option[(List[String], String)] = {
       Some((x.paramsSig.map(_.toString), x.resSig.toString))
     }

compiler/src/dotty/tools/dotc/tastyreflect/StandardDefinitions.scala

@@ -8,7 +8,7 @@ trait StandardDefinitions extends scala.tasty.reflect.StandardDefinitions {
 
   private implicit def ctx: Context = rootContext
 
-  val definitions: DefinitionsApi = new DefinitionsApi {
+  val definitions: DefinitionsAPI = new DefinitionsAPI {
 
     def RootPackage: Symbol = defn.RootPackage
     def RootClass: Symbol = defn.RootClass

compiler/src/dotty/tools/dotc/tastyreflect/SymbolOpsImpl.scala

@@ -78,7 +78,7 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
 
   }
 
-  object IsPackageSymbol extends IsPackageSymbolExtractor {
+  object IsPackageSymbol extends IsPackageSymbolModule {
     def unapply(symbol: Symbol)(implicit ctx: Context): Option[PackageSymbol] =
       if (symbol.is(Flags.Package)) Some(symbol) else None
   }
@@ -87,7 +87,7 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
     def tree(implicit ctx: Context): PackageDef = FromSymbol.packageDefFromSym(symbol)
   }
 
-  object IsTypeSymbol extends IsTypeSymbolExtractor {
+  object IsTypeSymbol extends IsTypeSymbolModule {
     def unapply(symbol: Symbol)(implicit ctx: Context): Option[TypeSymbol] =
       if (symbol.isType) Some(symbol.asType) else None
   }
@@ -100,7 +100,7 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
     def of(fullName: String)(implicit ctx: Context): ClassSymbol = ctx.requiredClass(fullName)
   }
 
-  object IsClassSymbol extends IsClassSymbolExtractor {
+  object IsClassSymbol extends IsClassSymbolModule {
     def unapply(symbol: Symbol)(implicit ctx: Context): Option[ClassSymbol] =
       if (symbol.isClass) Some(symbol.asClass) else None
   }
@@ -164,7 +164,7 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
     private def isField(sym: Symbol)(implicit ctx: Context): Boolean = sym.isTerm && !sym.is(Flags.Method)
   }
 
-  object IsDefSymbol extends IsDefSymbolExtractor {
+  object IsDefSymbol extends IsDefSymbolModule {
     def unapply(symbol: Symbol)(implicit ctx: Context): Option[DefSymbol] =
       if (symbol.isTerm && symbol.is(Flags.Method)) Some(symbol.asTerm) else None
   }
@@ -173,7 +173,7 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
     def tree(implicit ctx: Context): DefDef = FromSymbol.defDefFromSym(symbol)
   }
 
-  object IsValSymbol extends IsValSymbolExtractor {
+  object IsValSymbol extends IsValSymbolModule {
     def unapply(symbol: Symbol)(implicit ctx: Context): Option[ValSymbol] =
       if (symbol.isTerm && !symbol.is(Flags.Method) && !symbol.is(Flags.Case)) Some(symbol.asTerm) else None
   }
@@ -187,7 +187,7 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
     }
   }
 
-  object IsBindSymbol extends IsBindSymbolExtractor {
+  object IsBindSymbol extends IsBindSymbolModule {
     def unapply(symbol: Symbol)(implicit ctx: Context): Option[BindSymbol] =
       if (symbol.isTerm && symbol.is(Flags.Case)) Some(symbol.asTerm) else None // TODO
   }
@@ -196,7 +196,7 @@ trait SymbolOpsImpl extends scala.tasty.reflect.SymbolOps with CoreImpl {
     def tree(implicit ctx: Context): Bind = FromSymbol.bindFromSym(symbol)
   }
 
-  object NoSymbol extends NoSymbolExtractor {
+  object NoSymbol extends NoSymbolModule {
     def unapply(symbol: Symbol)(implicit ctx: Context): Boolean = symbol ne core.Symbols.NoSymbol
   }
 }