Merge pull request #4425 from dotty-staging/change-tasty-definitions

Replace Names with Strings in Macro API

Author: odersky

tests/pos/tasty/definitions.scala

@@ -2,40 +2,6 @@ package tasty
 
 object definitions {
 
-// ====== Names ======================================
-
-  trait Name
-  trait PossiblySignedName
-
-  enum TermName extends Name with PossiblySignedName {
-    case Simple(str: String)
-    case Qualified(prefix: TermName, selector: String)              // s"$prefix.$name"
-
-    case DefaultGetter(methodName: TermName, idx: String)           // s"$methodName${"$default$"}${idx+1}"
-    case Variant(underlying: TermName, covariant: Boolean)          // s"${if (covariant) "+" else "-"}$underlying"
-    case SuperAccessor(underlying: TermName)                        // s"${"super$"}$underlying"
-    case ProtectedAccessor(underlying: TermName)                    // s"${"protected$"}$underlying"
-    case ProtectedSetter(underlying: TermName)                      // s"${"protected$set"}$underlying"
-    case ObjectClass(underlying: TermName)                          // s"$underlying${"$"}"
-  }
-
-  case class SignedName(name: TermName, resultSig: TypeName, paramSigs: List[TypeName]) extends PossiblySignedName
-
-  case class TypeName(name: TermName) extends Name
-
-// ====== Positions ==================================
-
-  case class Position(firstOffset: Int, lastOffset: Int, sourceFile: String) {
-    def startLine: Int = ???
-    def startColumn: Int = ???
-    def endLine: Int = ???
-    def endColumn: Int = ???
-  }
-
-  trait Positioned {
-    def pos: Position = ???
-  }
-
 // ====== Trees ======================================
 
   trait Tree extends Positioned
@@ -64,34 +30,34 @@ object definitions {
   }
 
   // Does DefDef need a `def tpe: MethodType | PolyType`?
-  case class ValDef(name: TermName, tpt: TypeTree, rhs: Option[Term]) extends Definition {
+  case class ValDef(name: String, tpt: TypeTree, rhs: Option[Term]) extends Definition {
     def mods: List[Modifier] = ???
   }
-  case class DefDef(name: TermName, typeParams: List[TypeDef], paramss: List[List[ValDef]],
+  case class DefDef(name: String, typeParams: List[TypeDef], paramss: List[List[ValDef]],
                     returnTpt: TypeTree, rhs: Option[Term]) extends Definition {
     def mods: List[Modifier] = ???
   }
-  case class TypeDef(name: TypeName, rhs: TypeTree | TypeBoundsTree) extends Definition {
+  case class TypeDef(name: String, rhs: TypeTree | TypeBoundsTree) extends Definition {
     def mods: List[Modifier] = ???
   }
-  case class ClassDef(name: TypeName, constructor: DefDef, parents: List[Term | TypeTree],
+  case class ClassDef(name: String, constructor: DefDef, parents: List[Term | TypeTree],
                       self: Option[ValDef], body: List[Statement]) extends Definition {
     def mods: List[Modifier] = ???
   }
-  case class PackageDef(name: TermName, members: List[Statement]) extends Definition
+  case class PackageDef(name: String, members: List[Statement]) extends Definition
 
 // ------ Terms ---------------------------------
 
   /** Trees denoting terms */
   enum Term extends Statement {
     def tpe: Type = ???
-    case Ident(name: TermName, override val tpe: Type)
-    case Select(prefix: Term, name: PossiblySignedName)
+    case Ident(name: String, override val tpe: Type)
+    case Select(prefix: Term, name: String, signature: Option[Signature])
     case Literal(value: Constant)
     case This(id: Option[Id])
     case New(tpt: TypeTree)
     case Throw(expr: Term)
-    case NamedArg(name: TermName, arg: Term)
+    case NamedArg(name: String, arg: Term)
     case Apply(fn: Term, args: List[Term])
     case TypeApply(fn: Term, args: List[TypeTree])
     case Super(thiz: Term, mixin: Option[Id])
@@ -112,8 +78,8 @@ object definitions {
   enum TypeTree extends Tree {
     def tpe: Type = ???
     case Synthetic()
-    case Ident(name: TypeName, override val tpe: Type)
-    case Select(prefix: Term, name: TypeName)
+    case Ident(name: String, override val tpe: Type)
+    case Select(prefix: Term, name: String)
     case Singleton(ref: Term)
     case Refined(underlying: TypeTree, refinements: List[Definition])
     case Applied(tycon: TypeTree, args: List[TypeTree])
@@ -132,7 +98,7 @@ object definitions {
   enum Pattern extends Tree {
     def tpe: Type = ???
     case Value(v: Term)
-    case Bind(name: TermName, pat: Pattern)
+    case Bind(name: String, pat: Pattern)
     case Unapply(unapply: Term, implicits: List[Term], pats: List[Pattern])
     case Alternative(pats: List[Pattern])
     case TypeTest(tpt: TypeTree)
@@ -150,15 +116,16 @@ object definitions {
 
     case class ConstantType(value: Constant) extends Type
     case class SymRef(sym: Definition, qualifier: Type | NoPrefix = NoPrefix) extends Type
-    case class NameRef(name: Name, qualifier: Type | NoPrefix = NoPrefix) extends Type // NoPrefix means: select from _root_
+    case class TypeNameRef(name: String, qualifier: Type | NoPrefix = NoPrefix) extends Type // NoPrefix means: select from _root_
+    case class TermNameRef(name: String, qualifier: Type | NoPrefix = NoPrefix) extends Type // NoPrefix means: select from _root_
     case class SuperType(thistp: Type, underlying: Type) extends Type
-    case class Refinement(underlying: Type, name: Name, tpe: Type | TypeBounds) extends Type
+    case class Refinement(underlying: Type, name: String, tpe: Type | TypeBounds) extends Type
     case class AppliedType(tycon: Type, args: List[Type | TypeBounds]) extends Type
     case class AnnotatedType(underlying: Type, annotation: Term) extends Type
     case class AndType(left: Type, right: Type) extends Type
     case class OrType(left: Type, right: Type) extends Type
     case class ByNameType(underlying: Type) extends Type
-    case class ParamRef(binder: LambdaType[_, _, _], idx: Int) extends Type
+    case class ParamRef(binder: LambdaType[_, _], idx: Int) extends Type
     case class ThisType(tp: Type) extends Type
     case class RecursiveThis(binder: RecursiveType) extends Type
 
@@ -173,46 +140,46 @@ object definitions {
       }
     }
 
-    abstract class LambdaType[ParamName, ParamInfo, This <: LambdaType[ParamName, ParamInfo, This]](
-      val companion: LambdaTypeCompanion[ParamName, ParamInfo, This]
+    abstract class LambdaType[ParamInfo, This <: LambdaType[ParamInfo, This]](
+      val companion: LambdaTypeCompanion[ParamInfo, This]
     ) extends Type {
       private[Type] var _pinfos: List[ParamInfo]
       private[Type] var _restpe: Type
 
-      def paramNames: List[ParamName]
+      def paramNames: List[String]
       def paramInfos: List[ParamInfo] = _pinfos
       def resultType: Type = _restpe
     }
 
-    abstract class LambdaTypeCompanion[ParamName, ParamInfo, This <: LambdaType[ParamName, ParamInfo, This]] {
-      def apply(pnames: List[ParamName], ptypes: List[ParamInfo], restpe: Type): This
+    abstract class LambdaTypeCompanion[ParamInfo, This <: LambdaType[ParamInfo, This]] {
+      def apply(pnames: List[String], ptypes: List[ParamInfo], restpe: Type): This
 
-      def apply(pnames: List[ParamName], ptypesExp: This => List[ParamInfo], restpeExp: This => Type): This = {
+      def apply(pnames: List[String], ptypesExp: This => List[ParamInfo], restpeExp: This => Type): This = {
         val lambda = apply(pnames, Nil, PlaceHolder)
         lambda._pinfos = ptypesExp(lambda)
         lambda._restpe = restpeExp(lambda)
         lambda
       }
     }
 
-    case class MethodType(paramNames: List[TermName], private[Type] var _pinfos: List[Type], private[Type] var _restpe: Type)
-    extends LambdaType[TermName, Type, MethodType](MethodType) {
+    case class MethodType(paramNames: List[String], private[Type] var _pinfos: List[Type], private[Type] var _restpe: Type)
+    extends LambdaType[Type, MethodType](MethodType) {
       def isImplicit = (companion `eq` ImplicitMethodType) || (companion `eq` ErasedImplicitMethodType)
       def isErased = (companion `eq` ErasedMethodType) || (companion `eq` ErasedImplicitMethodType)
     }
 
-    case class PolyType(paramNames: List[TypeName], private[Type] var _pinfos: List[TypeBounds], private[Type] var _restpe: Type)
-    extends LambdaType[TypeName, TypeBounds, PolyType](PolyType)
+    case class PolyType(paramNames: List[String], private[Type] var _pinfos: List[TypeBounds], private[Type] var _restpe: Type)
+    extends LambdaType[TypeBounds, PolyType](PolyType)
 
-    case class TypeLambda(paramNames: List[TypeName], private[Type] var _pinfos: List[TypeBounds], private[Type] var _restpe: Type)
-    extends LambdaType[TypeName, TypeBounds, TypeLambda](TypeLambda)
+    case class TypeLambda(paramNames: List[String], private[Type] var _pinfos: List[TypeBounds], private[Type] var _restpe: Type)
+    extends LambdaType[TypeBounds, TypeLambda](TypeLambda)
 
-    object TypeLambda extends LambdaTypeCompanion[TypeName, TypeBounds, TypeLambda]
-    object PolyType   extends LambdaTypeCompanion[TypeName, TypeBounds, PolyType]
-    object MethodType extends LambdaTypeCompanion[TermName, Type, MethodType]
+    object TypeLambda extends LambdaTypeCompanion[TypeBounds, TypeLambda]
+    object PolyType   extends LambdaTypeCompanion[TypeBounds, PolyType]
+    object MethodType extends LambdaTypeCompanion[Type, MethodType]
 
-    class SpecializedMethodTypeCompanion extends LambdaTypeCompanion[TermName, Type, MethodType] { self =>
-      def apply(pnames: List[TermName], ptypes: List[Type], restpe: Type): MethodType =
+    class SpecializedMethodTypeCompanion extends LambdaTypeCompanion[Type, MethodType] { self =>
+      def apply(pnames: List[String], ptypes: List[Type], restpe: Type): MethodType =
         new MethodType(pnames, ptypes, restpe) { override val companion = self }
     }
     object ImplicitMethodType       extends SpecializedMethodTypeCompanion
@@ -227,7 +194,6 @@ object definitions {
 
 // ====== Modifiers ==================================
 
-
   enum Modifier {
     case Flags(flags: FlagSet)
     case QualifiedPrivate(boundary: Type)
@@ -264,6 +230,21 @@ object definitions {
     def isStable: Boolean                // Method that is assumed to be stable
   }
 
+  case class Signature(paramSigs: List[String], resultSig: String)
+
+// ====== Positions ==================================
+
+  case class Position(firstOffset: Int, lastOffset: Int, sourceFile: String) {
+    def startLine: Int = ???
+    def startColumn: Int = ???
+    def endLine: Int = ???
+    def endColumn: Int = ???
+  }
+
+  trait Positioned {
+    def pos: Position = ???
+  }
+
 // ====== Constants ==================================
 
   enum Constant(val value: Any) {