Rename Reflection.Type to TypeRepr

community-build/sbt-scalajs-sbt

@@ -0,0 +1 @@
+addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.3.0")

community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala

@@ -88,13 +88,16 @@ class CommunityBuildTest:
   // @Test def dottyCpsAsync = projects.dottyCpsAsync.run()
   @Test def effpi = projects.effpi.run()
   @Test def endpoints4s = projects.endpoints4s.run()
+  @Test def fansi = projects.fansi.run()
   @Test def fastparse = projects.fastparse.run()
   @Test def geny = projects.geny.run()
   @Test def intent = projects.intent.run()
   @Test def minitest = projects.minitest.run()
   @Test def munit = projects.munit.run()
   @Test def oslib = projects.oslib.run()
   // @Test def oslibWatch = projects.oslibWatch.run()
+  @Test def pprint = projects.pprint.run()
+  @Test def requests = projects.requests.run()
   @Test def scalacheck = projects.scalacheck.run()
   @Test def scalap = projects.scalap.run()
   @Test def scalaParserCombinators = projects.scalaParserCombinators.run()
@@ -114,9 +117,6 @@ class CommunityBuildTest:
   @Test def ujson = projects.ujson.run()
   @Test def upickle = projects.upickle.run()
   @Test def utest = projects.utest.run()
-  @Test def fansi = projects.fansi.run()
-  @Test def pprint = projects.pprint.run()
-  @Test def requests = projects.requests.run()
   @Test def xmlInterpolator = projects.xmlInterpolator.run()
   @Test def zio = projects.zio.run()
 end CommunityBuildTest

library/src-bootstrapped/scala/internal/quoted/Type.scala

@@ -44,30 +44,30 @@ object Type {
   // TODO generalize following optimizations for all classes without parameters
 
   def Unit: QuoteContext ?=> quoted.Type[Unit] =
-    qctx.reflect.Type.typeConstructorOf(classOf[Unit]).seal.asInstanceOf[quoted.Type[Unit]]
+    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Unit]).seal.asInstanceOf[quoted.Type[Unit]]
 
   def Boolean: QuoteContext ?=> quoted.Type[Boolean] =
-    qctx.reflect.Type.typeConstructorOf(classOf[Boolean]).seal.asInstanceOf[quoted.Type[Boolean]]
+    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Boolean]).seal.asInstanceOf[quoted.Type[Boolean]]
 
   def Byte: QuoteContext ?=> quoted.Type[Byte] =
-    qctx.reflect.Type.typeConstructorOf(classOf[Byte]).seal.asInstanceOf[quoted.Type[Byte]]
+    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Byte]).seal.asInstanceOf[quoted.Type[Byte]]
 
   def Char: QuoteContext ?=> quoted.Type[Char] =
-    qctx.reflect.Type.typeConstructorOf(classOf[Char]).seal.asInstanceOf[quoted.Type[Char]]
+    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Char]).seal.asInstanceOf[quoted.Type[Char]]
 
   def Short: QuoteContext ?=> quoted.Type[Short] =
-    qctx.reflect.Type.typeConstructorOf(classOf[Short]).seal.asInstanceOf[quoted.Type[Short]]
+    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Short]).seal.asInstanceOf[quoted.Type[Short]]
 
   def Int: QuoteContext ?=> quoted.Type[Int] =
-    qctx.reflect.Type.typeConstructorOf(classOf[Int]).seal.asInstanceOf[quoted.Type[Int]]
+    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Int]).seal.asInstanceOf[quoted.Type[Int]]
 
   def Long: QuoteContext ?=> quoted.Type[Long] =
-    qctx.reflect.Type.typeConstructorOf(classOf[Long]).seal.asInstanceOf[quoted.Type[Long]]
+    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Long]).seal.asInstanceOf[quoted.Type[Long]]
 
   def Float: QuoteContext ?=> quoted.Type[Float] =
-    qctx.reflect.Type.typeConstructorOf(classOf[Float]).seal.asInstanceOf[quoted.Type[Float]]
+    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Float]).seal.asInstanceOf[quoted.Type[Float]]
 
   def Double: QuoteContext ?=> quoted.Type[Double] =
-    qctx.reflect.Type.typeConstructorOf(classOf[Double]).seal.asInstanceOf[quoted.Type[Double]]
+    qctx.reflect.TypeRepr.typeConstructorOf(classOf[Double]).seal.asInstanceOf[quoted.Type[Double]]
 
 }

library/src-bootstrapped/scala/quoted/Liftable.scala

@@ -88,7 +88,7 @@ object Liftable {
   given ClassLiftable[T] as Liftable[Class[T]] = new Liftable[Class[T]] {
     def toExpr(x: Class[T]) = {
       import qctx.reflect._
-      Ref(defn.Predef_classOf).appliedToType(Type.typeConstructorOf(x)).seal.asInstanceOf[Expr[Class[T]]]
+      Ref(defn.Predef_classOf).appliedToType(TypeRepr.typeConstructorOf(x)).seal.asInstanceOf[Expr[Class[T]]]
     }
   }
 

library/src-bootstrapped/scala/quoted/util/ExprMap.scala

@@ -16,7 +16,7 @@ trait ExprMap {
         def localCtx(definition: Definition): Context = definition.symbol.localContext
         tree match {
           case tree: Term =>
-            transformTerm(tree, Type.of[Any])
+            transformTerm(tree, TypeRepr.of[Any])
           case tree: Definition =>
             transformDefinition(tree)
           case tree: Import =>
@@ -42,7 +42,7 @@ trait ExprMap {
         }
       }
 
-      def transformTermChildren(tree: Term, tpe: Type)(using ctx: Context): Term = tree match {
+      def transformTermChildren(tree: Term, tpe: TypeRepr)(using ctx: Context): Term = tree match {
         case Ident(name) =>
           tree
         case Select(qualifier, name) =>
@@ -53,17 +53,17 @@ trait ExprMap {
           tree
         case tree as Apply(fun, args) =>
           val MethodType(_, tpes, _) = fun.tpe.widen
-          Apply.copy(tree)(transformTerm(fun, Type.of[Any]), transformTerms(args, tpes))
+          Apply.copy(tree)(transformTerm(fun, TypeRepr.of[Any]), transformTerms(args, tpes))
         case TypeApply(fun, args) =>
-          TypeApply.copy(tree)(transformTerm(fun, Type.of[Any]), args)
+          TypeApply.copy(tree)(transformTerm(fun, TypeRepr.of[Any]), args)
         case _: Literal =>
           tree
         case New(tpt) =>
           New.copy(tree)(transformTypeTree(tpt))
         case Typed(expr, tpt) =>
           val tp = tpt.tpe match
-            case AppliedType(TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "<repeated>"), List(tp0: Type)) =>
-              Type.of[Seq].appliedTo(tp0)
+            case AppliedType(TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "<repeated>"), List(tp0: TypeRepr)) =>
+              TypeRepr.of[Seq].appliedTo(tp0)
             case tp => tp
           Typed.copy(tree)(transformTerm(expr, tp), transformTypeTree(tpt))
         case tree: NamedArg =>
@@ -74,7 +74,7 @@ trait ExprMap {
           Block.copy(tree)(transformStats(stats), transformTerm(expr, tpe))
         case If(cond, thenp, elsep) =>
           If.copy(tree)(
-            transformTerm(cond, Type.of[Boolean]),
+            transformTerm(cond, TypeRepr.of[Boolean]),
             transformTerm(thenp, tpe),
             transformTerm(elsep, tpe))
         case _: Closure =>
@@ -87,16 +87,16 @@ trait ExprMap {
           // Return.copy(tree)(transformTerm(expr, expr.tpe))
           tree
         case While(cond, body) =>
-          While.copy(tree)(transformTerm(cond, Type.of[Boolean]), transformTerm(body, Type.of[Any]))
+          While.copy(tree)(transformTerm(cond, TypeRepr.of[Boolean]), transformTerm(body, TypeRepr.of[Any]))
         case Try(block, cases, finalizer) =>
-          Try.copy(tree)(transformTerm(block, tpe), transformCaseDefs(cases, Type.of[Any]), finalizer.map(x => transformTerm(x, Type.of[Any])))
+          Try.copy(tree)(transformTerm(block, tpe), transformCaseDefs(cases, TypeRepr.of[Any]), finalizer.map(x => transformTerm(x, TypeRepr.of[Any])))
         case Repeated(elems, elemtpt) =>
           Repeated.copy(tree)(transformTerms(elems, elemtpt.tpe), elemtpt)
         case Inlined(call, bindings, expansion) =>
           Inlined.copy(tree)(call, transformDefinitions(bindings), transformTerm(expansion, tpe)/*()call.symbol.localContext)*/)
       }
 
-      def transformTerm(tree: Term, tpe: Type)(using ctx: Context): Term =
+      def transformTerm(tree: Term, tpe: TypeRepr)(using ctx: Context): Term =
         tree match
           case _: Closure =>
             tree
@@ -112,8 +112,8 @@ trait ExprMap {
 
       def transformTypeTree(tree: TypeTree)(using ctx: Context): TypeTree = tree
 
-      def transformCaseDef(tree: CaseDef, tpe: Type)(using ctx: Context): CaseDef =
-        CaseDef.copy(tree)(tree.pattern, tree.guard.map(x => transformTerm(x, Type.of[Boolean])), transformTerm(tree.rhs, tpe))
+      def transformCaseDef(tree: CaseDef, tpe: TypeRepr)(using ctx: Context): CaseDef =
+        CaseDef.copy(tree)(tree.pattern, tree.guard.map(x => transformTerm(x, TypeRepr.of[Boolean])), transformTerm(tree.rhs, tpe))
 
       def transformTypeCaseDef(tree: TypeCaseDef)(using ctx: Context): TypeCaseDef = {
         TypeCaseDef.copy(tree)(transformTypeTree(tree.pattern), transformTypeTree(tree.rhs))
@@ -125,21 +125,21 @@ trait ExprMap {
       def transformDefinitions(trees: List[Definition])(using ctx: Context): List[Definition] =
         trees mapConserve (transformDefinition(_))
 
-      def transformTerms(trees: List[Term], tpes: List[Type])(using ctx: Context): List[Term] =
+      def transformTerms(trees: List[Term], tpes: List[TypeRepr])(using ctx: Context): List[Term] =
         var tpes2 = tpes // TODO use proper zipConserve
         trees mapConserve { x =>
           val tpe :: tail = tpes2
           tpes2 = tail
           transformTerm(x, tpe)
         }
 
-      def transformTerms(trees: List[Term], tpe: Type)(using ctx: Context): List[Term] =
+      def transformTerms(trees: List[Term], tpe: TypeRepr)(using ctx: Context): List[Term] =
         trees.mapConserve(x => transformTerm(x, tpe))
 
       def transformTypeTrees(trees: List[TypeTree])(using ctx: Context): List[TypeTree] =
         trees mapConserve (transformTypeTree(_))
 
-      def transformCaseDefs(trees: List[CaseDef], tpe: Type)(using ctx: Context): List[CaseDef] =
+      def transformCaseDefs(trees: List[CaseDef], tpe: TypeRepr)(using ctx: Context): List[CaseDef] =
         trees mapConserve (x => transformCaseDef(x, tpe))
 
       def transformTypeCaseDefs(trees: List[TypeCaseDef])(using ctx: Context): List[TypeCaseDef] =