Merge pull request #9545 from dotty-staging/move-out-methods-form-reflect-context

Move out methods form reflect context

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -49,26 +49,30 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
 
   def Context_owner(self: Context): Symbol = self.owner
 
-  def Context_source(self: Context): java.nio.file.Path = self.compilationUnit.source.file.jpath
 
-  def Context_GADT_setFreshGADTBounds(self: Context): Context =
+  /////////////////
+  // Constraints //
+  /////////////////
+
+  def Constraints_init(self: Context): Context =
     self.fresh.setFreshGADTBounds.addMode(Mode.GadtConstraintInference)
 
-  def Context_GADT_addToConstraint(self: Context)(syms: List[Symbol]): Boolean =
+  def Constraints_add(self: Context)(syms: List[Symbol]): Boolean =
     self.gadt.addToConstraint(syms)
 
-  def Context_GADT_approximation(self: Context)(sym: Symbol, fromBelow: Boolean): Type =
+  def Constraints_approximation(self: Context)(sym: Symbol, fromBelow: Boolean): Type =
     self.gadt.approximation(sym, fromBelow)
 
-  def Context_requiredPackage(self: Context)(path: String): Symbol = requiredPackage(path)(using self)
-  def Context_requiredClass(self: Context)(path: String): Symbol = requiredClass(path)(using self)
-  def Context_requiredModule(self: Context)(path: String): Symbol = requiredModule(path)(using self)
-  def Context_requiredMethod(self: Context)(path: String): Symbol = requiredMethod(path)(using self)
-  def Context_isJavaCompilationUnit(self: Context): Boolean = self.compilationUnit.isInstanceOf[fromtasty.JavaCompilationUnit]
-  def Context_isScala2CompilationUnit(self: Context): Boolean = self.compilationUnit.isInstanceOf[fromtasty.Scala2CompilationUnit]
-  def Context_isAlreadyLoadedCompilationUnit(self: Context): Boolean = self.compilationUnit.isInstanceOf[fromtasty.AlreadyLoadedCompilationUnit]
-  def Context_compilationUnitClassname(self: Context): String =
-    self.compilationUnit match {
+  ////////////
+  // Source //
+  ////////////
+
+  def Source_path(using Context): java.nio.file.Path = ctx.compilationUnit.source.file.jpath
+  def Source_isJavaCompilationUnit(using Context): Boolean = ctx.compilationUnit.isInstanceOf[fromtasty.JavaCompilationUnit]
+  def Source_isScala2CompilationUnit(using Context): Boolean = ctx.compilationUnit.isInstanceOf[fromtasty.Scala2CompilationUnit]
+  def Source_isAlreadyLoadedCompilationUnit(using Context): Boolean = ctx.compilationUnit.isInstanceOf[fromtasty.AlreadyLoadedCompilationUnit]
+  def Source_compilationUnitClassname(using Context): String =
+    ctx.compilationUnit match {
       case cu: fromtasty.JavaCompilationUnit => cu.className
       case cu: fromtasty.Scala2CompilationUnit => cu.className
       case cu: fromtasty.AlreadyLoadedCompilationUnit => cu.className
@@ -1779,6 +1783,11 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
 
   private def isField(sym: Symbol)(using Context): Boolean = sym.isTerm && !sym.is(Flags.Method)
 
+  def Symbol_requiredPackage(path: String)(using Context): Symbol = requiredPackage(path)
+  def Symbol_requiredClass(path: String)(using Context): Symbol = requiredClass(path)
+  def Symbol_requiredModule(path: String)(using Context): Symbol = requiredModule(path)
+  def Symbol_requiredMethod(path: String)(using Context): Symbol = requiredMethod(path)
+
   def Symbol_of(fullName: String)(using Context): Symbol =
     requiredClass(fullName)
 

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

@@ -147,14 +147,14 @@ object Matcher {
     def termMatch(scrutineeTerm: Term, patternTerm: Term, hasTypeSplices: Boolean): Option[Tuple] = {
       given Env = Map.empty
       if (hasTypeSplices) {
-        val ctx: Context = internal.Context_GADT_setFreshGADTBounds(rootContext)
+        val ctx: Context = internal.Constraints_init(rootContext)
         given Context = ctx
         val matchings = scrutineeTerm =?= patternTerm
         // 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 =>
           Tuple.fromArray(tup.toArray.map { // TODO improve performance
-            case x: SymBinding => internal.Context_GADT_approximation(summon[Context])(x.sym, !x.fromAbove).seal
+            case x: SymBinding => internal.Constraints_approximation(summon[Context])(x.sym, !x.fromAbove).seal
             case x => x
           })
         }
@@ -168,14 +168,14 @@ object Matcher {
     def typeTreeMatch(scrutineeTypeTree: TypeTree, patternTypeTree: TypeTree, hasTypeSplices: Boolean): Option[Tuple] = {
       given Env = Map.empty
       if (hasTypeSplices) {
-        val ctx: Context = internal.Context_GADT_setFreshGADTBounds(rootContext)
+        val ctx: Context = internal.Constraints_init(rootContext)
         given Context = ctx
         val matchings = scrutineeTypeTree =?= patternTypeTree
         // 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 =>
           Tuple.fromArray(tup.toArray.map { // TODO improve performance
-            case x: SymBinding => internal.Context_GADT_approximation(summon[Context])(x.sym, !x.fromAbove).seal
+            case x: SymBinding => internal.Constraints_approximation(summon[Context])(x.sym, !x.fromAbove).seal
             case x => x
           })
         }
@@ -323,7 +323,7 @@ object Matcher {
             fn1 =?= fn2 &&& args1 =?= args2
 
           case (Block(stats1, expr1), Block(binding :: stats2, expr2)) if isTypeBinding(binding) =>
-            qctx.tasty.internal.Context_GADT_addToConstraint(summon[Context])(binding.symbol :: Nil)
+            qctx.tasty.internal.Constraints_add(summon[Context])(binding.symbol :: Nil)
             matched(new SymBinding(binding.symbol, hasFromAboveAnnotation(binding.symbol))) &&& Block(stats1, expr1) =?= Block(stats2, expr2)
 
           /* Match block */
@@ -340,7 +340,7 @@ object Matcher {
 
           case (scrutinee, Block(typeBindings, expr2)) if typeBindings.forall(isTypeBinding) =>
             val bindingSymbols = typeBindings.map(_.symbol)
-            qctx.tasty.internal.Context_GADT_addToConstraint(summon[Context])(bindingSymbols)
+            qctx.tasty.internal.Constraints_add(summon[Context])(bindingSymbols)
             bindingSymbols.foldRight(scrutinee =?= expr2)((x, acc) => matched(new SymBinding(x, hasFromAboveAnnotation(x))) &&& acc)
 
           /* Match if */

library/src/scala/tasty/Reflection.scala

@@ -426,35 +426,32 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
     extension (self: Context):
       /** Returns the owner of the context */
       def owner: Symbol = internal.Context_owner(self)
+    end extension
+  end Context
 
-      /** Returns the source file being compiled. The path is relative to the current working directory. */
-      def source: java.nio.file.Path = internal.Context_source(self)
 
-      /** Get package symbol if package is either defined in current compilation run or present on classpath. */
-      def requiredPackage(path: String): Symbol = internal.Context_requiredPackage(self)(path)
+  ///////////////
+  //   Source  //
+  ///////////////
 
-      /** Get class symbol if class is either defined in current compilation run or present on classpath. */
-      def requiredClass(path: String): Symbol = internal.Context_requiredClass(self)(path)
+  object Source:
 
-      /** Get module symbol if module is either defined in current compilation run or present on classpath. */
-      def requiredModule(path: String): Symbol = internal.Context_requiredModule(self)(path)
+    /** Returns the source file being compiled. The path is relative to the current working directory. */
+    def path(using ctx: Context): java.nio.file.Path = internal.Source_path
 
-      /** Get method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload. */
-      def requiredMethod(path: String): Symbol = internal.Context_requiredMethod(self)(path)
+    /** Returns true if we've tried to reflect on a Java class. */
+    def isJavaCompilationUnit(using ctx: Context): Boolean = internal.Source_isJavaCompilationUnit
 
-      /** Returns true if we've tried to reflect on a Java class. */
-      def isJavaCompilationUnit(): Boolean = internal Context_isJavaCompilationUnit(self)
+    /** Returns true if we've tried to reflect on a Scala2 (non-Tasty) class. */
+    def isScala2CompilationUnit(using ctx: Context): Boolean = internal.Source_isScala2CompilationUnit
 
-      /** Returns true if we've tried to reflect on a Scala2 (non-Tasty) class. */
-      def isScala2CompilationUnit(): Boolean = internal Context_isScala2CompilationUnit(self)
+    /** Returns true if we've tried to reflect on a class that's already loaded (e.g. Option). */
+    def isAlreadyLoadedCompilationUnit(using ctx: Context): Boolean = internal.Source_isAlreadyLoadedCompilationUnit
 
-      /** Returns true if we've tried to reflect on a class that's already loaded (e.g. Option). */
-      def isAlreadyLoadedCompilationUnit(): Boolean = internal.Context_isAlreadyLoadedCompilationUnit(self)
+    /** Class name of the current CompilationUnit */
+    def compilationUnitClassname(using ctx: Context): String = internal.Source_compilationUnitClassname
 
-      /** Class name of the current CompilationUnit */
-      def compilationUnitClassname(): String = internal.Context_compilationUnitClassname(self)
-    end extension
-  end Context
+  end Source
 
 
   ///////////////
@@ -2306,6 +2303,19 @@ class Reflection(private[scala] val internal: CompilerInterface) { self =>
   given SymbolOps as Symbol.type = Symbol
 
   object Symbol:
+
+    /** Get package symbol if package is either defined in current compilation run or present on classpath. */
+    def requiredPackage(path: String)(using ctx: Context): Symbol = internal.Symbol_requiredPackage(path)
+
+    /** Get class symbol if class is either defined in current compilation run or present on classpath. */
+    def requiredClass(path: String)(using ctx: Context): Symbol = internal.Symbol_requiredClass(path)
+
+    /** Get module symbol if module is either defined in current compilation run or present on classpath. */
+    def requiredModule(path: String)(using ctx: Context): Symbol = internal.Symbol_requiredModule(path)
+
+    /** Get method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload. */
+    def requiredMethod(path: String)(using ctx: Context): Symbol = internal.Symbol_requiredMethod(path)
+
     /** The class Symbol of a global class definition */
     def classSymbol(fullName: String)(using ctx: Context): Symbol =
       internal.Symbol_of(fullName)

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -141,37 +141,32 @@ trait CompilerInterface {
   /** Returns the owner of the context */
   def Context_owner(self: Context): Symbol
 
-  /** Returns the source file being compiled. The path is relative to the current working directory. */
-  def Context_source(self: Context): java.nio.file.Path
-
-  def Context_GADT_setFreshGADTBounds(self: Context): Context
-  def Context_GADT_addToConstraint(self: Context)(syms: List[Symbol]): Boolean
-  def Context_GADT_approximation(self: Context)(sym: Symbol, fromBelow: Boolean): Type
-
-  /** Get package symbol if package is either defined in current compilation run or present on classpath. */
-  def Context_requiredPackage(self: Context)(path: String): Symbol
+  /////////////////
+  // Constraints //
+  /////////////////
 
-  /** Get class symbol if class is either defined in current compilation run or present on classpath. */
-  def Context_requiredClass(self: Context)(path: String): Symbol
+  def Constraints_init(self: Context): Context
+  def Constraints_add(self: Context)(syms: List[Symbol]): Boolean
+  def Constraints_approximation(self: Context)(sym: Symbol, fromBelow: Boolean): Type
 
-  /** Get module symbol if module is either defined in current compilation run or present on classpath. */
-  def Context_requiredModule(self: Context)(path: String): Symbol
+  ////////////
+  // Source //
+  ////////////
 
-  /** Get method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload. */
-  def Context_requiredMethod(self: Context)(path: String): Symbol
+  /** Returns the source file being compiled. The path is relative to the current working directory. */
+  def Source_path(using ctx: Context): java.nio.file.Path
 
   /** Returns true if we've tried to reflect on a Java class. */
-  def Context_isJavaCompilationUnit(self: Context): Boolean
+  def Source_isJavaCompilationUnit(using ctx: Context): Boolean
 
   /** Returns true if we've tried to reflect on a Scala2 (non-Tasty) class. */
-  def Context_isScala2CompilationUnit(self: Context): Boolean
+  def Source_isScala2CompilationUnit(using ctx: Context): Boolean
 
   /** Returns true if we've tried to reflect on a class that's already loaded (e.g. Option). */
-  def Context_isAlreadyLoadedCompilationUnit(self: Context): Boolean
+  def Source_isAlreadyLoadedCompilationUnit(using ctx: Context): Boolean
 
   /** Class name of the current CompilationUnit */
-  def Context_compilationUnitClassname(self: Context): String
-
+  def Source_compilationUnitClassname(using ctx: Context): String
 
   ///////////////
   // REPORTING //
@@ -1330,6 +1325,18 @@ trait CompilerInterface {
   /** Fields of a case class type -- only the ones declared in primary constructor */
   def Symbol_caseFields(self: Symbol)(using ctx: Context): List[Symbol]
 
+  /** Get package symbol if package is either defined in current compilation run or present on classpath. */
+  def Symbol_requiredPackage(path: String)(using ctx: Context): Symbol
+
+  /** Get class symbol if class is either defined in current compilation run or present on classpath. */
+  def Symbol_requiredClass(path: String)(using ctx: Context): Symbol
+
+  /** Get module symbol if module is either defined in current compilation run or present on classpath. */
+  def Symbol_requiredModule(path: String)(using ctx: Context): Symbol
+
+  /** Get method symbol if method is either defined in current compilation run or present on classpath. Throws if the method has an overload. */
+  def Symbol_requiredMethod(path: String)(using ctx: Context): Symbol
+
   def Symbol_of(fullName: String)(using ctx: Context): Symbol
 
   def Symbol_newMethod(parent: Symbol, name: String, flags: Flags, tpe: Type, privateWithin: Symbol)(using ctx: Context): Symbol