Seal quoted.Expr and quoted.Type

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala

@@ -12,7 +12,8 @@ import dotty.tools.dotc.core.NameKinds
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.tasty.{TastyPickler, TastyPrinter, TastyString}
 
-import scala.quoted.Quoted._
+import scala.quoted.Types._
+import scala.quoted.Exprs._
 
 import scala.reflect.ClassTag
 

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -21,7 +21,8 @@ import typer.Checking
 import config.Config
 import dotty.tools.dotc.core.quoted.PickledQuotes
 import scala.quoted
-import scala.quoted.Quoted.{RawExpr, RawType}
+import scala.quoted.Types.RawType
+import scala.quoted.Exprs.RawExpr
 
 /** Unpickler for typed trees
  *  @param reader          the reader from which to unpickle

compiler/src/dotty/tools/dotc/interpreter/Interpreter.scala

@@ -73,8 +73,8 @@ class Interpreter(implicit ctx: Context) {
 
     tree match {
       case Quoted(quotedTree) =>
-        if (tree.isTerm) new scala.quoted.Quoted.RawExpr(quotedTree)
-        else new scala.quoted.Quoted.RawType(quotedTree)
+        if (tree.isTerm) new scala.quoted.Exprs.RawExpr(quotedTree)
+        else new scala.quoted.Types.RawType(quotedTree)
 
       case Literal(Constant(c)) => c.asInstanceOf[Object]
 

compiler/src/dotty/tools/dotc/quoted/Runners.scala

@@ -7,7 +7,7 @@ import dotty.tools.dotc.printing.RefinedPrinter
 
 import scala.quoted.Expr
 import scala.runtime.BoxedUnit
-import scala.quoted.Quoted.ConstantExpr
+import scala.quoted.Exprs.ConstantExpr
 import scala.runtime.quoted._
 
 /** Default runners for quoted expressions */

docs/docs/reference/principled-meta-programming.md

@@ -445,7 +445,7 @@ to be executed at a later stage. To run that code, there is another method
 in class `Expr` called `run`. Note that `~` and `run` both map from `Expr[T]`
 to `T` but only `~` is subject to the PCP, whereas `run` is just a normal method.
 
-    abstract class Expr[T] {
+    sealed abstract class Expr[T] {
       def unary_~: T
       def run(implicit runner: Runner[T]): T       // run staged code
       def show(implicit runner: Runner[T]): String // show staged code

library/src/scala/quoted/Expr.scala

@@ -1,9 +1,9 @@
 package scala.quoted
 
-import scala.quoted.Quoted.FunctionAppliedTo
 import scala.runtime.quoted.Runner
+import scala.runtime.quoted.Unpickler.Pickled
 
-abstract class Expr[T] extends Quoted {
+sealed abstract class Expr[T] extends Quoted {
   final def unary_~ : T = throw new Error("~ should have been compiled away")
   final def run(implicit runner: Runner[T]): T = runner.run(this)
   final def show(implicit runner: Runner[T]): String = runner.show(this)
@@ -14,7 +14,30 @@ object Expr {
     ev.toExpr(x)
 
   implicit class AsFunction[T, U](private val f: Expr[T => U]) extends AnyVal {
-    def apply(x: Expr[T]): Expr[U] = new FunctionAppliedTo[T, U](f, x)
+    def apply(x: Expr[T]): Expr[U] = new Exprs.FunctionAppliedTo[T, U](f, x)
   }
 
 }
+
+/** All implementations of Expr[T] */
+object Exprs {
+  /** An Expr backed by a pickled TASTY tree */
+  final class TastyExpr[T](val tasty: Pickled, val args: Seq[Any]) extends Expr[T] {
+    override def toString(): String = s"Expr(<pickled>)"
+  }
+
+  /** An Expr backed by a value */
+  final class ConstantExpr[T](val value: T) extends Expr[T] {
+    override def toString: String = s"Expr($value)"
+  }
+
+  /** An Expr backed by a tree */
+  final class RawExpr[Tree](val tree: Tree) extends quoted.Expr[Any] {
+    override def toString: String = s"Expr(<raw>)"
+  }
+
+  /** An Expr representing `'{(~f).apply(~x)}` but it is beta-reduced when the closure is known */
+  final class FunctionAppliedTo[T, U](val f: Expr[T => U], val x: Expr[T]) extends Expr[U] {
+    override def toString: String = s"Expr($f <applied to> $x)"
+  }
+}

library/src/scala/quoted/Liftable.scala

@@ -1,6 +1,6 @@
 package scala.quoted
 
-import scala.quoted.Quoted.ConstantExpr
+import scala.quoted.Exprs.ConstantExpr
 
 /** A typeclass for types that can be turned to `quoted.Expr[T]`
  *  without going through an explicit `'(...)` operation.

library/src/scala/quoted/Quoted.scala

@@ -1,50 +1,4 @@
 package scala.quoted
 
-import scala.reflect.ClassTag
-import scala.runtime.quoted.Unpickler.Pickled
-
 /** Common superclass of Expr and Type */
 abstract class Quoted
-
-object Quoted {
-
-  // Implementations of Expr[T]
-
-  /** An Expr backed by a pickled TASTY tree */
-  final class TastyExpr[T](val tasty: Pickled, val args: Seq[Any]) extends Expr[T] {
-    override def toString(): String = s"Expr(<pickled>)"
-  }
-
-  /** An Expr backed by a value */
-  final class ConstantExpr[T](val value: T) extends Expr[T] {
-    override def toString: String = s"Expr($value)"
-  }
-
-  /** An Expr backed by a tree */
-  final class RawExpr[Tree](val tree: Tree) extends quoted.Expr[Any] {
-    override def toString: String = s"Expr(<raw>)"
-  }
-
-  /** An Expr representing `'{(~f).apply(~x)}` but it is beta-reduced when the closure is known */
-  final class FunctionAppliedTo[T, U](val f: Expr[T => U], val x: Expr[T]) extends Expr[U] {
-    override def toString: String = s"Expr($f <applied to> $x)"
-  }
-
-  // Implementations of Type[T]
-
-  /** A Type backed by a pickled TASTY tree */
-  final class TastyType[T](val tasty: Pickled, val args: Seq[Any]) extends Type[T] {
-    override def toString(): String = s"Type(<pickled>)"
-  }
-
-  /** An Type backed by a value */
-  final class TaggedType[T](implicit val ct: ClassTag[T]) extends Type[T] {
-    override def toString: String = s"Type($ct)"
-  }
-
-  /** An Type backed by a tree */
-  final class RawType[Tree](val tree: Tree) extends quoted.Type[Any] {
-    override def toString: String = s"Type(<raw>)"
-  }
-
-}

library/src/scala/quoted/Type.scala

@@ -1,8 +1,10 @@
 package scala.quoted
 
-import scala.quoted.Quoted.TaggedType
+import scala.quoted.Types.TaggedType
+import scala.reflect.ClassTag
+import scala.runtime.quoted.Unpickler.Pickled
 
-abstract class Type[T] extends Quoted {
+sealed abstract class Type[T] extends Quoted {
   type unary_~ = T
 }
 
@@ -18,3 +20,21 @@ object Type {
   implicit def FloatTag: Type[Float] = new TaggedType[Float]
   implicit def DoubleTag: Type[Double] = new TaggedType[Double]
 }
+
+/** Implementations of Type[T] */
+object Types {
+  /** A Type backed by a pickled TASTY tree */
+  final class TastyType[T](val tasty: Pickled, val args: Seq[Any]) extends Type[T] {
+    override def toString(): String = s"Type(<pickled>)"
+  }
+
+  /** An Type backed by a value */
+  final class TaggedType[T](implicit val ct: ClassTag[T]) extends Type[T] {
+    override def toString: String = s"Type($ct)"
+  }
+
+  /** An Type backed by a tree */
+  final class RawType[Tree](val tree: Tree) extends quoted.Type[Any] {
+    override def toString: String = s"Type(<raw>)"
+  }
+}

library/src/scala/runtime/quoted/Unpickler.scala

@@ -1,6 +1,7 @@
 package scala.runtime.quoted
 
-import scala.quoted.Quoted.{TastyExpr, TastyType}
+import scala.quoted.Types.TastyType
+import scala.quoted.Exprs.TastyExpr
 import scala.quoted.{Expr, Type}
 
 /** Provides methods to unpickle `Expr` and `Type` trees. */