Add scala.quoted.Scope

Author: nicolasstucki

.github/workflows/ci.yaml

@@ -8,6 +8,7 @@ import Names._, StdNames._, NameOps._, Symbols._
 import typer.ConstFold
 import reporting.trace
 import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.transform.TypeUtils._
 import Decorators._
 import Constants.Constant
 import scala.collection.mutable
@@ -395,7 +396,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case New(_) | Closure(_, _, _) =>
       Pure
     case TypeApply(fn, _) =>
-      if (fn.symbol.is(Erased) || fn.symbol == defn.QuotedTypeModule_apply || fn.symbol == defn.Predef_classOf) Pure else exprPurity(fn)
+      if (fn.symbol.is(Erased) || fn.symbol == defn.ScopeTypeModule_apply || fn.symbol == defn.Predef_classOf) Pure else exprPurity(fn)
     case Apply(fn, args) =>
       def isKnownPureOp(sym: Symbol) =
         sym.owner.isPrimitiveValueClass
@@ -908,7 +909,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       *  will return a type tree.
       */
     def unapply(tree: tpd.Select)(using Context): Option[tpd.Tree] =
-      if tree.symbol.isTypeSplice then Some(tree.qualifier) else None
+      if tree.tpe.isTypeSplice || (tree.qualifier.tpe.widenTermRefExpr.typeSymbol == defn.ScopeTypeClass && tree.name == tpnme.spliceType) then Some(tree.qualifier)
+      else None
   }
 
   /** Extractor for not-null assertions.

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -56,6 +56,8 @@ object Trees {
   abstract class Tree[-T >: Untyped](implicit @constructorOnly src: SourceFile)
   extends Positioned, SrcPos, Product, Attachment.Container, printing.Showable {
 
+    type X <: AnyKind // FIXME used for reflection. find another way to add this type
+
     if (Stats.enabled) ntrees += 1
 
     /** The type  constructor at the root of the tree */

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -786,22 +786,16 @@ class Definitions {
   @tu lazy val ClassTagModule: Symbol = ClassTagClass.companionModule
     @tu lazy val ClassTagModule_apply: Symbol = ClassTagModule.requiredMethod(nme.apply)
 
+  @tu lazy val QuotedExprModule: Symbol = requiredModule("scala.quoted.Expr")
 
-  @tu lazy val QuotedExprClass: ClassSymbol = requiredClass("scala.quoted.Expr")
-  @tu lazy val QuotedExprModule: Symbol = QuotedExprClass.companionModule
-
-  @tu lazy val QuoteContextClass: ClassSymbol = requiredClass("scala.quoted.QuoteContext")
+  @tu lazy val TastyReflectionClass: ClassSymbol = requiredClass("scala.tasty.Reflection")
 
-  @tu lazy val LiftableModule: Symbol = requiredModule("scala.quoted.Liftable")
-    @tu lazy val LiftableModule_BooleanIsLiftable: Symbol = LiftableModule.requiredMethod("BooleanIsLiftable")
-    @tu lazy val LiftableModule_ByteIsLiftable: Symbol = LiftableModule.requiredMethod("ByteIsLiftable")
-    @tu lazy val LiftableModule_ShortIsLiftable: Symbol = LiftableModule.requiredMethod("ShortIsLiftable")
-    @tu lazy val LiftableModule_IntIsLiftable: Symbol = LiftableModule.requiredMethod("IntIsLiftable")
-    @tu lazy val LiftableModule_LongIsLiftable: Symbol = LiftableModule.requiredMethod("LongIsLiftable")
-    @tu lazy val LiftableModule_FloatIsLiftable: Symbol = LiftableModule.requiredMethod("FloatIsLiftable")
-    @tu lazy val LiftableModule_DoubleIsLiftable: Symbol = LiftableModule.requiredMethod("DoubleIsLiftable")
-    @tu lazy val LiftableModule_CharIsLiftable: Symbol = LiftableModule.requiredMethod("CharIsLiftable")
-    @tu lazy val LiftableModule_StringIsLiftable: Symbol = LiftableModule.requiredMethod("StringIsLiftable")
+  @tu lazy val ScopeClass: ClassSymbol = requiredClass("scala.quoted.Scope")
+  @tu lazy val ScopeTypeModule: Symbol = ScopeClass.requiredMethod("Type")
+  @tu lazy val ScopeTypeModule_apply: Symbol = ScopeTypeModule.requiredMethod(nme.apply)
+  @tu lazy val ScopeExprClass: Symbol = ScopeClass.typeRef.select(tpnme.Expr).typeSymbol
+  @tu lazy val ScopeTypeClass: Symbol = ScopeClass.typeRef.select(tpnme.Type).typeSymbol
+    @tu lazy val Scope_Type_splice: Symbol = ScopeClass.typeRef.select(tpnme.Type).select(tpnme.spliceType).typeSymbol
 
   @tu lazy val InternalQuotedModule: Symbol = requiredModule("scala.internal.quoted.CompileTime")
     @tu lazy val InternalQuoted_exprQuote  : Symbol = InternalQuotedModule.requiredMethod("exprQuote")
@@ -820,18 +814,19 @@ class Definitions {
     @tu lazy val InternalQuotedExpr_unapply: Symbol = InternalQuotedExprModule.requiredMethod(nme.unapply)
     @tu lazy val InternalQuotedExpr_null: Symbol = InternalQuotedExprModule.requiredMethod(nme.null_)
     @tu lazy val InternalQuotedExpr_unit: Symbol = InternalQuotedExprModule.requiredMethod(nme.Unit)
+    @tu lazy val InternalQuotedExpr_liftBoolean: Symbol = InternalQuotedExprModule.requiredMethod("liftBoolean")
+    @tu lazy val InternalQuotedExpr_liftByte: Symbol = InternalQuotedExprModule.requiredMethod("liftByte")
+    @tu lazy val InternalQuotedExpr_liftShort: Symbol = InternalQuotedExprModule.requiredMethod("liftShort")
+    @tu lazy val InternalQuotedExpr_liftInt: Symbol = InternalQuotedExprModule.requiredMethod("liftInt")
+    @tu lazy val InternalQuotedExpr_liftLong: Symbol = InternalQuotedExprModule.requiredMethod("liftLong")
+    @tu lazy val InternalQuotedExpr_liftFloat: Symbol = InternalQuotedExprModule.requiredMethod("liftFloat")
+    @tu lazy val InternalQuotedExpr_liftDouble: Symbol = InternalQuotedExprModule.requiredMethod("liftDouble")
+    @tu lazy val InternalQuotedExpr_liftChar: Symbol = InternalQuotedExprModule.requiredMethod("liftChar")
+    @tu lazy val InternalQuotedExpr_liftString: Symbol = InternalQuotedExprModule.requiredMethod("liftString")
 
   @tu lazy val InternalQuotedTypeModule: Symbol = requiredModule("scala.internal.quoted.Type")
     @tu lazy val InternalQuotedType_unapply: Symbol = InternalQuotedTypeModule.requiredMethod(nme.unapply)
 
-  @tu lazy val QuotedTypeClass: ClassSymbol = requiredClass("scala.quoted.Type")
-    @tu lazy val QuotedType_splice: Symbol = QuotedTypeClass.requiredType(tpnme.spliceType)
-
-  @tu lazy val QuotedTypeModule: Symbol = QuotedTypeClass.companionModule
-    @tu lazy val QuotedTypeModule_apply: Symbol = QuotedTypeModule.requiredMethod("apply")
-
-  @tu lazy val TastyReflectionClass: ClassSymbol = requiredClass("scala.tasty.Reflection")
-
   @tu lazy val Unpickler_unpickleExpr: Symbol = requiredMethod("scala.internal.quoted.Unpickler.unpickleExpr")
   @tu lazy val Unpickler_unpickleType: Symbol = requiredMethod("scala.internal.quoted.Unpickler.unpickleType")
 

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -17,9 +17,9 @@ object StagingContext {
   private val QuotationLevel = new Property.Key[Int]
 
   /** A key to be used in a context property that tracks the quoteation stack.
-   *  Stack containing the QuoteContext references recieved by the surrounding quotes.
+   *  Stack containing the Scope references recieved by the surrounding quotes.
    */
-  private val QuoteContextStack = new Property.Key[List[tpd.Tree]]
+  private val ScopeStack = new Property.Key[List[tpd.Tree]]
 
   private val TaggedTypes = new Property.Key[PCPCheckAndHeal.QuoteTypeTags]
 
@@ -31,11 +31,11 @@ object StagingContext {
   def quoteContext(using Context): Context =
     ctx.fresh.setProperty(QuotationLevel, level + 1)
 
-  /** Context with an incremented quotation level and pushes a refecence to a QuoteContext on the quote context stack */
-  def pushQuoteContext(qctxRef: tpd.Tree)(using Context): Context =
-    val old = ctx.property(QuoteContextStack).getOrElse(List.empty)
+  /** Context with an incremented quotation level and pushes a refecence to a Scope on the quote scope stack */
+  def pushScope(scopeRef: tpd.Tree)(using Context): Context =
+    val old = ctx.property(ScopeStack).getOrElse(List.empty)
     ctx.fresh.setProperty(QuotationLevel, level + 1)
-             .setProperty(QuoteContextStack, qctxRef :: old)
+             .setProperty(ScopeStack, scopeRef :: old)
 
   /** Context with a decremented quotation level. */
   def spliceContext(using Context): Context =
@@ -47,17 +47,23 @@ object StagingContext {
   def getQuoteTypeTags(using Context): PCPCheckAndHeal.QuoteTypeTags =
     ctx.property(TaggedTypes).get
 
-  /** Context with a decremented quotation level and pops the Some of top of the quote context stack or None if the stack is empty.
+  /** Context with a decremented quotation level and pops the Some of top of the quote scope stack or None if the stack is empty.
    *  The quotation stack could be empty if we are in a top level splice or an eroneous splice directly witin a top level splice.
    */
-  def popQuoteContext()(using Context): (Option[tpd.Tree], Context) =
+  def popScope()(using Context): (Option[tpd.Tree], Context) =
     val ctx1 = ctx.fresh.setProperty(QuotationLevel, level - 1)
     val head =
-      ctx.property(QuoteContextStack) match
+      ctx.property(ScopeStack) match
         case Some(x :: xs) =>
-          ctx1.setProperty(QuoteContextStack, xs)
+          ctx1.setProperty(ScopeStack, xs)
           Some(x)
         case _ =>
           None // Splice at level 0 or lower
     (head, ctx1)
+
+  def peekScope()(implicit ctx: Context): Option[tpd.Tree] =
+    ctx.property(ScopeStack) match
+      case Some(x :: xs) => Some(x)
+      case _ => None // Splice at level 0 or lower
+
 }

compiler/src/dotty/tools/dotc/core/StagingContext.scala

@@ -582,7 +582,7 @@ object StdNames {
     val setSymbol: N            = "setSymbol"
     val setType: N              = "setType"
     val setTypeSignature: N     = "setTypeSignature"
-    val spliceType: N           = "T"
+    val spliceType: N           = "X"
     val standardInterpolator: N = "standardInterpolator"
     val staticClass : N         = "staticClass"
     val staticModule : N        = "staticModule"

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -92,6 +92,8 @@ object Types {
    */
   abstract class Type extends Hashable with printing.Showable {
 
+    type X <: AnyKind // FIXME used for reflection. find another way to add this type
+
 // ----- Tests -----------------------------------------------------
 
 //    // debug only: a unique identifier for a type

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -734,7 +734,7 @@ class TreePickler(pickler: TastyPickler) {
 
   def pickle(trees: List[Tree])(using Context): Unit = {
     trees.foreach(tree => if (!tree.isEmpty) pickleTree(tree))
-    def missing = forwardSymRefs.keysIterator.map(sym => sym.showLocated + "(line " + sym.srcPos.line + ")").toList
+    def missing = forwardSymRefs.keysIterator.map(sym => sym.showLocated + (if sym.sourcePos.exists then "(line " + sym.srcPos.line + ")" else "")).toList
     assert(forwardSymRefs.isEmpty, i"unresolved symbols: $missing%, % when pickling ${ctx.source}")
   }
 

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

@@ -8,7 +8,7 @@ import scala.io.Codec
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.tasty.TastyPrinter
-import dotty.tools.dotc.quoted.QuoteContextImpl
+import dotty.tools.dotc.quoted.ScopeImpl
 import dotty.tools.io.File
 
 /** Phase that prints the trees in all loaded compilation units.
@@ -43,7 +43,7 @@ class DecompilationPrinter extends Phase {
     else {
       val unitFile = unit.source.toString.replace("\\", "/").replace(".class", ".tasty")
       out.println(s"/** Decompiled from $unitFile */")
-      out.println(QuoteContextImpl.showTree(unit.tpdTree))
+      out.println(ScopeImpl.showTree(unit.tpdTree))
     }
   }
 }

compiler/src/dotty/tools/dotc/decompiler/DecompilationPrinter.scala

@@ -6,7 +6,7 @@ import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core._
 import dotty.tools.dotc.core.tasty.TastyHTMLPrinter
 import dotty.tools.dotc.reporting._
-import dotty.tools.dotc.quoted.QuoteContextImpl
+import dotty.tools.dotc.quoted.ScopeImpl
 
 /**
   * Decompiler to be used with IDEs
@@ -34,7 +34,7 @@ class IDEDecompilerDriver(val settings: List[String]) extends dotc.Driver {
       run.printSummary()
       val unit = ctx.run.units.head
 
-      val decompiled = QuoteContextImpl.showTree(unit.tpdTree)
+      val decompiled = ScopeImpl.showTree(unit.tpdTree)
       val tree = new TastyHTMLPrinter(unit.pickled.head._2()).printContents()
 
       reporter.removeBufferedMessages.foreach(message => System.err.println(message))