Initialize constraints on the QuoteContext

Author: nicolasstucki

compiler/src/dotty/tools/dotc/quoted/reflect/ReflectionCompilerInterface.scala

@@ -55,8 +55,10 @@ class ReflectionCompilerInterface(val rootContext: Context) extends CompilerInte
   // Constraints //
   /////////////////
 
-  def Constraints_init(self: Context): Context =
-    self.fresh.setFreshGADTBounds.addMode(Mode.GadtConstraintInference)
+
+  def Constraints_context[T]: scala.quoted.QuoteContext =
+    val ctx = rootContext.fresh.setFreshGADTBounds.addMode(Mode.GadtConstraintInference)
+    dotty.tools.dotc.quoted.QuoteContext()(using ctx)
 
   def Constraints_add(self: Context)(syms: List[Symbol]): Boolean =
     self.gadt.addToConstraint(syms)

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

@@ -53,7 +53,10 @@ object Expr {
    */
   def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeExpr: scala.quoted.Expr[Any])(using patternExpr: scala.quoted.Expr[Any],
         hasTypeSplices: Boolean, qctx: QuoteContext): Option[Tup] = {
-    new Matcher.QuoteMatcher[qctx.type](qctx).termMatch(scrutineeExpr.unseal, patternExpr.unseal, hasTypeSplices).asInstanceOf[Option[Tup]]
+    val qctx1 = quoteContextWithCompilerInterface(qctx)
+    val qctx2 = if hasTypeSplices then qctx1.tasty.Constraints_context else qctx1
+    given qctx2.type = qctx2
+    new Matcher.QuoteMatcher[qctx2.type](qctx2).termMatch(scrutineeExpr.unseal, patternExpr.unseal, hasTypeSplices).asInstanceOf[Option[Tup]]
   }
 
   /** Returns a null expresssion equivalent to `'{null}` */

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

@@ -149,10 +149,9 @@ object Matcher {
 
     def termMatch(scrutineeTerm: Term, patternTerm: Term, hasTypeSplices: Boolean): Option[Tuple] = {
       given Env = Map.empty
-      if (hasTypeSplices) {
-        val ctx: Context = qctx.tasty.Constraints_init(rootContext)
-        given Context = ctx
-        val matchings = scrutineeTerm =?= patternTerm
+      val matchings = scrutineeTerm =?= patternTerm
+      if !hasTypeSplices then matchings
+      else {
         // After matching and doing all subtype checks, we have to approximate all the type bindings
         // that we have found and seal them in a quoted.Type
         matchings.asOptionOfTuple.map { tup =>
@@ -162,18 +161,14 @@ object Matcher {
           })
         }
       }
-      else {
-        scrutineeTerm =?= patternTerm
-      }
     }
 
     // TODO factor out common logic with `termMatch`
     def typeTreeMatch(scrutineeTypeTree: TypeTree, patternTypeTree: TypeTree, hasTypeSplices: Boolean): Option[Tuple] = {
       given Env = Map.empty
-      if (hasTypeSplices) {
-        val ctx: Context = qctx.tasty.Constraints_init(rootContext)
-        given Context = ctx
-        val matchings = scrutineeTypeTree =?= patternTypeTree
+      val matchings = scrutineeTypeTree =?= patternTypeTree
+      if !hasTypeSplices then matchings
+      else {
         // After matching and doing all subtype checks, we have to approximate all the type bindings
         // that we have found and seal them in a quoted.Type
         matchings.asOptionOfTuple.map { tup =>
@@ -183,9 +178,6 @@ object Matcher {
           })
         }
       }
-      else {
-        scrutineeTypeTree =?= patternTypeTree
-      }
     }
 
     private def hasPatternTypeAnnotation(sym: Symbol) = sym.annots.exists(isPatternTypeAnnotation)

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

@@ -40,7 +40,10 @@ object Type {
    */
   def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeType: scala.quoted.Type[_])(using patternType: scala.quoted.Type[_],
         hasTypeSplices: Boolean, qctx: QuoteContext): Option[Tup] = {
-    new Matcher.QuoteMatcher[qctx.type](qctx).typeTreeMatch(scrutineeType.unseal, patternType.unseal, hasTypeSplices).asInstanceOf[Option[Tup]]
+    val qctx1 = quoteContextWithCompilerInterface(qctx)
+    val qctx2 = if hasTypeSplices then qctx1.tasty.Constraints_context else qctx1
+    given qctx2.type = qctx2
+    new Matcher.QuoteMatcher[qctx2.type](qctx2).typeTreeMatch(scrutineeType.unseal, patternType.unseal, hasTypeSplices).asInstanceOf[Option[Tup]]
   }
 
   def Unit: QuoteContext ?=> quoted.Type[Unit] =

library/src/scala/internal/tasty/CompilerInterface.scala

@@ -33,7 +33,7 @@ trait CompilerInterface extends scala.tasty.reflect.Types {
   // Constraints //
   /////////////////
 
-  def Constraints_init(self: Context): Context
+  def Constraints_context[T]: scala.quoted.QuoteContext
   def Constraints_add(self: Context)(syms: List[Symbol]): Boolean
   def Constraints_approximation(self: Context)(sym: Symbol, fromBelow: Boolean): Type
 

library/src/scala/tasty/Reflection.scala

@@ -1363,22 +1363,22 @@ trait Reflection extends reflect.Types { reflectSelf: CompilerInterface =>
 
   object Type:
 
-    def apply(clazz: Class[_])(using ctx: Context): Type =
+    def apply(clazz: Class[_]): Type =
       reflectSelf.Type_apply(clazz)
 
     extension (self: Type):
 
       /** Convert `Type` to an `quoted.Type[_]` */
-      def seal(using ctx: Context): scala.quoted.Type[_] =
+      def seal: scala.quoted.Type[_] =
         new scala.internal.quoted.Type(Inferred(self), reflectSelf.compilerId)
 
       /** Is `self` type the same as `that` type?
         *  This is the case iff `self <:< that` and `that <:< self`.
         */
-      def =:=(that: Type)(using ctx: Context): Boolean = reflectSelf.Type_isTypeEq(self)(that)
+      def =:=(that: Type): Boolean = reflectSelf.Type_isTypeEq(self)(that)
 
       /** Is this type a subtype of that type? */
-      def <:<(that: Type)(using ctx: Context): Boolean = reflectSelf.Type_isSubType(self)(that)
+      def <:<(that: Type): Boolean = reflectSelf.Type_isSubType(self)(that)
 
       /** Widen from singleton type to its underlying non-singleton
         *  base type by applying one or more `underlying` dereferences,
@@ -1992,6 +1992,7 @@ trait Reflection extends reflect.Types { reflectSelf: CompilerInterface =>
       /** The position of this symbol */
       def pos: Position = reflectSelf.Symbol_pos(sym)
 
+      // TODO replace with different abstraction
       def localContext(using ctx: Context): Context = ctx // reflectSelf.Symbol_localContext(sym)
 
       /** The comment for this symbol, if any */