Add missing TASTy Reflect type API

Author: nicolasstucki

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

@@ -78,6 +78,7 @@ trait CoreImpl extends scala.tasty.reflect.Core {
       type ByName = tpd.ByNameTypeTree
       type LambdaTypeTree = tpd.LambdaTypeTree
       type Bind = tpd.Bind
+      type Block = tpd.Block
     }
     type TypeBoundsTree = tpd.TypeBoundsTree
     type WildcardType = tpd.TypeTree
@@ -86,11 +87,26 @@ trait CoreImpl extends scala.tasty.reflect.Core {
     type NoPrefix = Types.NoPrefix.type
     type TypeBounds = Types.TypeBounds
     type Type = Types.Type
-    type RecursiveType = Types.RecType
-    type LambdaType[ParamInfo] = Types.LambdaType { type PInfo = ParamInfo }
-      type MethodType = Types.MethodType
-      type PolyType = Types.PolyType
-      type TypeLambda = Types.TypeLambda
+      type ConstantType = Types.ConstantType
+      type SymRef = Types.NamedType
+      type TermRef = Types.NamedType
+      type TypeRef = Types.NamedType
+      type SuperType = Types.SuperType
+      type Refinement = Types.RefinedType
+      type AppliedType = Types.AppliedType
+      type AnnotatedType = Types.AnnotatedType
+      type AndType = Types.AndType
+      type OrType = Types.OrType
+      type MatchType = Types.MatchType
+      type ByNameType = Types.ExprType
+      type ParamRef = Types.ParamRef
+      type ThisType = Types.ThisType
+      type RecursiveThis = Types.RecThis
+      type RecursiveType = Types.RecType
+      type LambdaType[ParamInfo] = Types.LambdaType { type PInfo = ParamInfo }
+        type MethodType = Types.MethodType
+        type PolyType = Types.PolyType
+        type TypeLambda = Types.TypeLambda
 
   type ImportSelector = untpd.Tree
 

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

@@ -1,6 +1,6 @@
 package dotty.tools.dotc.tastyreflect
 
-import dotty.tools.dotc.core.{Names, Types}
+import dotty.tools.dotc.core.{Contexts, Names, Types}
 
 trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreImpl {
 
@@ -41,13 +41,29 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreI
 
   object Type extends TypeModule {
 
+    object IsConstantType extends IsConstantTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[ConstantType] = ???
+    }
+
+    def ConstantTypeDeco(x: ConstantType): ConstantTypeAPI = new ConstantTypeAPI {
+
+    }
+
     object ConstantType extends ConstantTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[Constant] = x match {
         case Types.ConstantType(value) => Some(value)
         case _ => None
       }
     }
 
+    object IsSymRef extends IsSymRefModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[SymRef] = ???
+    }
+
+    def SymRefDeco(x: SymRef): SymRefAPI = new SymRefAPI {
+
+    }
+
     object SymRef extends SymRefExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Symbol, TypeOrBounds /* Type | NoPrefix */)] = x  match {
         case tp: Types.NamedType =>
@@ -59,6 +75,14 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreI
       }
     }
 
+    object IsTermRef extends IsTermRefModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[TermRef] = ???
+    }
+
+    def TermRefDeco(x: TermRef): TermRefAPI = new TermRefAPI {
+
+    }
+
     object TermRef extends TermRefExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(String, TypeOrBounds /* Type | NoPrefix */)] = x match {
         case tp: Types.NamedType =>
@@ -70,6 +94,14 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreI
       }
     }
 
+    object IsTypeRef extends IsTypeRefModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[TypeRef] = ???
+    }
+
+    def TypeRefDeco(x: TypeRef): TypeRefAPI = new TypeRefAPI {
+
+    }
+
     object TypeRef extends TypeRefExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(String, TypeOrBounds /* Type | NoPrefix */)] = x match {
         case tp: Types.NamedType =>
@@ -81,62 +113,134 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreI
       }
     }
 
+    object IsSuperType extends IsSuperTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[SuperType] = ???
+    }
+
+    def SuperTypeDeco(x: SuperType): SuperTypeAPI = new SuperTypeAPI {
+
+    }
+
     object SuperType extends SuperTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type)] = x match {
         case Types.SuperType(thistpe, supertpe) => Some(thistpe, supertpe)
         case _ => None
       }
     }
 
+    object IsRefinement extends IsRefinementModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Refinement] = ???
+    }
+
+    def RefinementDeco(x: Refinement): RefinementAPI = new RefinementAPI {
+
+    }
+
     object Refinement extends RefinementExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Type, String, TypeOrBounds /* Type | TypeBounds */)] = x match {
         case Types.RefinedType(parent, name, info) => Some(parent, name.toString, info)
         case _ => None
       }
     }
 
+    object IsAppliedType extends IsAppliedTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[AppliedType] = ???
+    }
+
+    def AppliedTypeDeco(x: AppliedType): AppliedTypeAPI = new AppliedTypeAPI {
+
+    }
+
     object AppliedType extends AppliedTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Type, List[TypeOrBounds /* Type | TypeBounds */])] = x match {
         case Types.AppliedType(tycon, args) => Some((tycon.stripTypeVar, args.map(_.stripTypeVar)))
         case _ => None
       }
     }
 
+    object IsAnnotatedType extends IsAnnotatedTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[AnnotatedType] = ???
+    }
+
+    def AnnotatedTypeDeco(x: AnnotatedType): AnnotatedTypeAPI = new AnnotatedTypeAPI {
+
+    }
+
     object AnnotatedType extends AnnotatedTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Type, Term)] = x match {
         case Types.AnnotatedType(underlying, annot) => Some((underlying.stripTypeVar, annot.tree))
         case _ => None
       }
     }
 
+    object IsAndType extends IsAndTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[AndType] = ???
+    }
+
+    def AndTypeDeco(x: AndType): AndTypeAPI = new AndTypeAPI {
+
+    }
+
     object AndType extends AndTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type)] = x match {
         case Types.AndType(left, right) => Some(left.stripTypeVar, right.stripTypeVar)
         case _ => None
       }
     }
 
+    object IsOrType extends IsOrTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[OrType] = ???
+    }
+
+    def OrTypeDeco(x: OrType): OrTypeAPI = new OrTypeAPI {
+
+    }
+
     object OrType extends OrTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type)] = x match {
         case Types.OrType(left, right) => Some(left.stripTypeVar, right.stripTypeVar)
         case _ => None
       }
     }
 
+    object IsMatchType extends IsMatchTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[MatchType] = ???
+    }
+
+    def MatchTypeDeco(x: MatchType): MatchTypeAPI = new MatchTypeAPI {
+
+    }
+
     object MatchType extends MatchTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type, List[Type])] = x match {
         case Types.MatchType(bound, scrutinee, cases) => Some((bound, scrutinee, cases))
         case _ => None
       }
     }
 
+    object IsByNameType extends IsByNameTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[ByNameType] = ???
+    }
+
+    def ByNameTypeDeco(x: ByNameType): ByNameTypeAPI = new ByNameTypeAPI {
+
+    }
+
     object ByNameType extends ByNameTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[Type] = x match {
         case Types.ExprType(resType) => Some(resType.stripTypeVar)
         case _ => None
       }
     }
 
+    object IsParamRef extends IsParamRefModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[ParamRef] = ???
+    }
+
+    def ParamRefDeco(x: ParamRef): ParamRefAPI = new ParamRefAPI {
+
+    }
+
     object ParamRef extends ParamRefExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(LambdaType[TypeOrBounds], Int)] = x match {
         case Types.TypeParamRef(binder, idx) =>
@@ -148,41 +252,89 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreI
       }
     }
 
+    object IsThisType extends IsThisTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[ThisType] = ???
+    }
+
+    def ThisTypeDeco(x: ThisType): ThisTypeAPI = new ThisTypeAPI {
+
+    }
+
     object ThisType extends ThisTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[Type] = x match {
         case Types.ThisType(tp) => Some(tp)
         case _ => None
       }
     }
 
+    object IsRecursiveThis extends IsRecursiveThisModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[RecursiveThis] = ???
+    }
+
+    def RecursiveThisDeco(x: RecursiveThis): RecursiveThisAPI = new RecursiveThisAPI {
+
+    }
+
     object RecursiveThis extends RecursiveThisExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[RecursiveType] = x match {
         case Types.RecThis(binder) => Some(binder)
         case _ => None
       }
     }
 
+    object IsRecursiveType extends IsRecursiveTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[RecursiveType] = ???
+    }
+
+    def RecursiveTypeDeco(x: RecursiveType): RecursiveTypeAPI = new RecursiveTypeAPI {
+
+    }
+
     object RecursiveType extends RecursiveTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[Type] = x match {
         case tp: Types.RecType => Some(tp.underlying.stripTypeVar)
         case _ => None
       }
     }
 
+    object IsMethodType extends IsMethodTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[MethodType] = ???
+    }
+
+    def MethodTypeDeco(x: MethodType): MethodTypeAPI = new MethodTypeAPI {
+
+    }
+
     object MethodType extends MethodTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(List[String], List[Type], Type)] = x match {
         case x: MethodType => Some(x.paramNames.map(_.toString), x.paramInfos, x.resType)
         case _ => None
       }
     }
 
+    object IsPolyType extends IsPolyTypeModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[PolyType] = ???
+    }
+
+    def PolyTypeDeco(x: PolyType): PolyTypeAPI = new PolyTypeAPI {
+
+    }
+
     object PolyType extends PolyTypeExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(List[String], List[TypeBounds], Type)] = x match {
         case x: PolyType => Some(x.paramNames.map(_.toString), x.paramInfos, x.resType)
         case _ => None
       }
     }
 
+    object IsTypeLambda extends IsTypeLambdaModule {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[TypeLambda] = ???
+    }
+
+    def TypeLambdaDeco(x: TypeLambda): TypeLambdaAPI = new TypeLambdaAPI {
+
+    }
+
     object TypeLambda extends TypeLambdaExtractor {
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(List[String], List[TypeBounds], Type)] = x match {
         case x: TypeLambda => Some(x.paramNames.map(_.toString), x.paramInfos, x.resType)