Move atPhase and friends to Contexts

odersky · odersky · commit f3e03fc4df6a · 2020-07-10T13:21:07.000+02:00
diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala
@@ -19,6 +19,7 @@ import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.Erasure
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.util.Spans._
+import dotty.tools.dotc.core.Contexts.{inContext, atPhase}
 
 /*
  *
@@ -1460,7 +1461,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
       // TODO specialization
       val constrainedType = new MethodBType(lambdaParamTypes.map(p => toTypeKind(p)), toTypeKind(lambdaTarget.info.resultType)).toASMType
 
-      val abstractMethod = ctx.atPhase(ctx.erasurePhase) {
+      val abstractMethod = atPhase(ctx.erasurePhase) {
         val samMethods = toDenot(functionalInterface).info.possibleSamMethods.toList
         samMethods match {
           case x :: Nil => x.symbol
diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala b/compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala
@@ -13,7 +13,7 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.ast.Trees
 import dotty.tools.dotc.core.Annotations._
 import dotty.tools.dotc.core.Constants._
-import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Contexts.{Context, atPhase}
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Names.Name
@@ -478,7 +478,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
      * @see https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3.4
      */
     def getGenericSignature(sym: Symbol, owner: Symbol): String = {
-      ctx.atPhase(ctx.erasurePhase) {
+      atPhase(ctx.erasurePhase) {
         val memberTpe =
           if (sym.is(Method)) sym.denot.info
           else owner.denot.thisType.memberInfo(sym)
@@ -913,7 +913,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     // But for now, just like we did in mixin, we just avoid writing a wrong generic signature
     // (one that doesn't erase to the actual signature). See run/t3452b for a test case.
 
-    val memberTpe = ctx.atPhase(ctx.erasurePhase) { moduleClass.denot.thisType.memberInfo(sym) }
+    val memberTpe = atPhase(ctx.erasurePhase) { moduleClass.denot.thisType.memberInfo(sym) }
     val erasedMemberType = TypeErasure.erasure(memberTpe)
     if (erasedMemberType =:= sym.denot.info)
       getGenericSignatureHelper(sym, moduleClass, memberTpe).orNull
diff --git a/compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala b/compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala
@@ -8,7 +8,7 @@ import scala.collection.mutable
 import scala.collection.generic.Clearable
 
 import dotty.tools.dotc.core.Flags._
-import dotty.tools.dotc.core.Contexts.inContext
+import dotty.tools.dotc.core.Contexts.{inContext, atPhase}
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.transform.SymUtils._
@@ -212,7 +212,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
 
   private def definedClasses(sym: Symbol, phase: Phase) =
     if (sym.isDefinedInCurrentRun)
-      ctx.atPhase(phase) {
+      atPhase(phase) {
         toDenot(sym).info.decls.filter(_.isClass)
       }
     else Nil
diff --git a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -160,7 +160,7 @@ object DottyBackendInterface {
      */
     def isTopLevelModuleClass(using Context): Boolean =
       sym.is(ModuleClass) &&
-      ctx.atPhase(ctx.flattenPhase) {
+      atPhase(ctx.flattenPhase) {
         toDenot(sym).owner.is(PackageClass)
       }
 
diff --git a/compiler/src/dotty/tools/backend/jvm/GenBCode.scala b/compiler/src/dotty/tools/backend/jvm/GenBCode.scala
@@ -166,7 +166,7 @@ class GenBCodePipeline(val int: DottyBackendInterface)(using ctx: Context) exten
             if (classSymbol.effectiveName.toString < dupClassSym.effectiveName.toString) (classSymbol, dupClassSym)
             else (dupClassSym, classSymbol)
           val same = classSymbol.effectiveName.toString == dupClassSym.effectiveName.toString
-          ctx.atPhase(ctx.typerPhase) {
+          atPhase(ctx.typerPhase) {
             if (same)
               summon[Context].warning( // FIXME: This should really be an error, but then FromTasty tests fail
                 s"${cl1.show} and ${cl2.showLocated} produce classes that overwrite one another", cl1.sourcePos)
@@ -271,7 +271,7 @@ class GenBCodePipeline(val int: DottyBackendInterface)(using ctx: Context) exten
 
       // ----------- compiler and sbt's callbacks
 
-      val (fullClassName, isLocal) = ctx.atPhase(ctx.sbtExtractDependenciesPhase) {
+      val (fullClassName, isLocal) = atPhase(ctx.sbtExtractDependenciesPhase) {
         (ExtractDependencies.classNameAsString(claszSymbol), claszSymbol.isLocal)
       }
 
diff --git a/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala b/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
@@ -2121,7 +2121,7 @@ class JSCodeGen()(using genCtx: Context) {
     if (isStat) {
       boxedResult
     } else {
-      val tpe = ctx.atPhase(ctx.elimErasedValueTypePhase) {
+      val tpe = atPhase(ctx.elimErasedValueTypePhase) {
         sym.info.finalResultType
       }
       unbox(boxedResult, tpe)
@@ -2735,14 +2735,14 @@ class JSCodeGen()(using genCtx: Context) {
     def paramNamesAndTypes(using Context): List[(Names.TermName, Type)] =
       sym.info.paramNamess.flatten.zip(sym.info.paramInfoss.flatten)
 
-    val wereRepeated = ctx.atPhase(ctx.elimRepeatedPhase) {
+    val wereRepeated = atPhase(ctx.elimRepeatedPhase) {
       val list =
         for ((name, tpe) <- paramNamesAndTypes)
         yield (name -> tpe.isRepeatedParam)
       list.toMap
     }
 
-    val paramTypes = ctx.atPhase(ctx.elimErasedValueTypePhase) {
+    val paramTypes = atPhase(ctx.elimErasedValueTypePhase) {
       paramNamesAndTypes.toMap
     }
 
diff --git a/compiler/src/dotty/tools/backend/sjs/JSInterop.scala b/compiler/src/dotty/tools/backend/sjs/JSInterop.scala
@@ -16,7 +16,7 @@ object JSInterop {
   /** Is this symbol a JavaScript type? */
   def isJSType(sym: Symbol)(using Context): Boolean = {
     //sym.hasAnnotation(jsdefn.RawJSTypeAnnot)
-    ctx.atPhase(ctx.erasurePhase) {
+    atPhase(ctx.erasurePhase) {
       sym.derivesFrom(jsdefn.JSAnyClass)
     }
   }
@@ -32,7 +32,7 @@ object JSInterop {
    *  much as *accessor* methods created for `val`s and `var`s.
    */
   def isJSGetter(sym: Symbol)(using Context): Boolean = {
-    sym.info.firstParamTypes.isEmpty && ctx.atPhase(ctx.erasurePhase) {
+    sym.info.firstParamTypes.isEmpty && atPhase(ctx.erasurePhase) {
       sym.info.isParameterless
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/config/Feature.scala b/compiler/src/dotty/tools/dotc/config/Feature.scala
@@ -36,7 +36,7 @@ object Feature:
    *       import owner.{ feature => _ }
    */
   def enabledByImport(feature: TermName, owner: Symbol = NoSymbol)(using Context): Boolean =
-    ctx.atPhase(ctx.typerPhase) {
+    atPhase(ctx.typerPhase) {
       ctx.importInfo != null
       && ctx.importInfo.featureImported(feature,
           if owner.exists then owner else defn.LanguageModule.moduleClass)
diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -57,6 +57,24 @@ object Contexts {
   inline def inContext[T](c: Context)(inline op: Context ?=> T): T =
     op(using c)
 
+  /** Execute `op` at given period */
+  inline def atPeriod[T](pd: Period)(inline op: Context ?=> T)(using Context): T =
+    op(using ctx.fresh.setPeriod(pd))
+
+  /** Execute `op` at given phase id */
+  inline def atPhase[T](pid: PhaseId)(inline op: Context ?=> T)(using Context): T =
+    op(using ctx.withPhase(pid))
+
+  /** Execute `op` at given phase */
+  inline def atPhase[T](phase: Phase)(inline op: Context ?=> T)(using Context): T =
+    atPhase(phase.id)(op)
+
+  inline def atNextPhase[T](inline op: Context ?=> T)(using Context): T =
+    atPhase(ctx.phase.next)(op)
+
+  inline def atPhaseNotLaterThan[T](limit: Phase)(inline op: Context ?=> T)(using Context): T =
+    op(using if !limit.exists || ctx.phase <= limit then ctx else ctx.withPhase(limit))
+
   /** A context is passed basically everywhere in dotc.
    *  This is convenient but carries the risk of captured contexts in
    *  objects that turn into space leaks. To combat this risk, here are some
diff --git a/compiler/src/dotty/tools/dotc/core/Periods.scala b/compiler/src/dotty/tools/dotc/core/Periods.scala
@@ -2,7 +2,7 @@ package dotty.tools.dotc.core
 
 import Contexts._
 
-/** Periods are the central "clock" of the compiler.
+/** Periods are the central "clock" of the compiler
  *  A period consists of a run id and a phase id.
  *  run ids represent compiler runs
  *  phase ids represent compiler phases
@@ -16,14 +16,6 @@ abstract class Periods { thisCtx: Context =>
   /** The current run identifier */
   def runId: Int = period.runId
 
-  /** Execute `op` at given period */
-  def atPeriod[T](pd: Period)(op: Context => T): T =
-    op(thisCtx.fresh.setPeriod(pd))
-
-  /** Execute `op` at given phase id */
-  inline def atPhase[T](pid: PhaseId)(inline op: Context ?=> T): T =
-    op(using thisCtx.withPhase(pid))
-
   /** The period containing the current period where denotations do not change.
    *  We compute this by taking as first phase the first phase less or equal to
    *  the current phase that has the same "nextTransformerId". As last phase
diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala
@@ -30,15 +30,6 @@ trait Phases {
       phase :: (if (rest.hasNext) rest.next().phasesStack else Nil)
     }
 
-  /** Execute `op` at given phase */
-  inline def atPhase[T](phase: Phase)(inline op: Context ?=> T): T =
-    atPhase(phase.id)(op)
-
-  def atNextPhase[T](op: Context ?=> T): T = atPhase(phase.next)(op)
-
-  def atPhaseNotLaterThan[T](limit: Phase)(op: Context ?=> T): T =
-    if (!limit.exists || phase <= limit) op(using this) else atPhase(limit)(op)
-
   def isAfterTyper: Boolean = base.isAfterTyper(phase)
 }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
@@ -42,7 +42,7 @@ class ElimByName extends TransformByNameApply with InfoTransformer {
   private def applyIfFunction(tree: Tree, ftree: Tree)(using Context) =
     if (isByNameRef(ftree)) {
       val tree0 = transformFollowing(tree)
-      ctx.atPhase(next) { tree0.select(defn.Function0_apply).appliedToNone }
+      atPhase(next) { tree0.select(defn.Function0_apply).appliedToNone }
     }
     else tree
 
@@ -61,7 +61,7 @@ class ElimByName extends TransformByNameApply with InfoTransformer {
   }
 
   override def transformValDef(tree: ValDef)(using Context): Tree =
-    ctx.atPhase(next) {
+    atPhase(next) {
       if (exprBecomesFunction(tree.symbol))
         cpy.ValDef(tree)(tpt = tree.tpt.withType(tree.symbol.info))
       else tree
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala
@@ -7,7 +7,7 @@ import Types._
 import dotty.tools.dotc.transform.MegaPhase._
 import ast.Trees._
 import Flags._
-import Contexts.{Context, ctx}
+import Contexts._
 import Symbols._
 import Constants._
 import Decorators._
@@ -113,7 +113,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
    *  Also transform trees inside method annotation
    */
   override def transformDefDef(tree: DefDef)(using Context): Tree =
-    ctx.atPhase(thisPhase) {
+    atPhase(thisPhase) {
       if (tree.symbol.info.isVarArgsMethod && overridesJava(tree.symbol))
         addVarArgsBridge(tree)
       else
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -904,7 +904,7 @@ object Erasure {
         case stat: DefDef @unchecked if stat.symbol.name.is(BodyRetainerName) =>
           val retainer = stat.symbol
           val origName = retainer.name.asTermName.exclude(BodyRetainerName)
-          val inlineMeth = ctx.atPhase(ctx.typerPhase) {
+          val inlineMeth = atPhase(ctx.typerPhase) {
             retainer.owner.info.decl(origName)
               .matchingDenotation(retainer.owner.thisType, stat.symbol.info)
               .symbol
diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
@@ -127,7 +127,7 @@ object ExplicitOuter {
 
   /** Ensure that class `cls` has outer accessors */
   def ensureOuterAccessors(cls: ClassSymbol)(using Context): Unit =
-    ctx.atPhase(ctx.explicitOuterPhase.next) {
+    atPhase(ctx.explicitOuterPhase.next) {
       if (!hasOuter(cls))
         newOuterAccessors(cls).foreach(_.enteredAfter(ctx.explicitOuterPhase.asInstanceOf[DenotTransformer]))
     }
diff --git a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala
@@ -184,7 +184,7 @@ object ExtensionMethods {
 
   /** Return the extension method that corresponds to given instance method `meth`. */
   def extensionMethod(imeth: Symbol)(using Context): TermSymbol =
-    ctx.atPhase(ctx.extensionMethodsPhase.next) {
+    atPhase(ctx.extensionMethodsPhase.next) {
       // FIXME use toStatic instead?
       val companion = imeth.owner.companionModule
       val companionInfo = companion.info
diff --git a/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala b/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala
@@ -35,7 +35,7 @@ class FunctionalInterfaces extends MiniPhase {
 
     if (defn.isSpecializableFunction(cls, implParamTypes, implResultType) &&
         !ctx.settings.scalajs.value) { // never do anything for Scala.js, but do this test as late as possible not to slow down Scala/JVM
-      val names = ctx.atPhase(ctx.erasurePhase) { cls.typeParams.map(_.name) }
+      val names = atPhase(ctx.erasurePhase) { cls.typeParams.map(_.name) }
       val interfaceName = (functionName ++ implParamTypes.length.toString).specializedFor(implParamTypes ::: implResultType :: Nil, names, Nil, Nil)
 
       // symbols loaded from classpath aren't defined in periods earlier than when they where loaded
diff --git a/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala b/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala
@@ -3,7 +3,7 @@ package dotc
 package transform
 
 import core.Annotations._
-import core.Contexts.{Context, ctx}
+import core.Contexts._
 import core.Definitions
 import core.Flags._
 import core.Names.{DerivedName, Name, SimpleName, TypeName}
@@ -112,7 +112,7 @@ object GenericSignatures {
     // a type parameter or similar) must go through here or the signature is
     // likely to end up with Foo<T>.Empty where it needs Foo<T>.Empty$.
     def fullNameInSig(sym: Symbol): Unit = {
-      val name = ctx.atPhase(ctx.genBCodePhase) { sanitizeName(sym.fullName).replace('.', '/') }
+      val name = atPhase(ctx.genBCodePhase) { sanitizeName(sym.fullName).replace('.', '/') }
       builder.append('L').append(name)
     }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala
@@ -370,7 +370,7 @@ object LambdaLift {
     }
 
     // initialization
-    ctx.atPhase(thisPhase) {
+    atPhase(thisPhase) {
       (new CollectDependencies).traverse(ctx.compilationUnit.tpdTree)
       computeFreeVars()
       computeLiftedOwners()
diff --git a/compiler/src/dotty/tools/dotc/transform/Mixin.scala b/compiler/src/dotty/tools/dotc/transform/Mixin.scala
@@ -4,7 +4,7 @@ package transform
 
 import core._
 import MegaPhase._
-import Contexts.{Context, ctx}
+import Contexts.{Context, ctx, atPhase}
 import Flags._
 import SymUtils._
 import Symbols._
@@ -222,7 +222,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
           transformFollowingDeep(superRef(baseCls.primaryConstructor).appliedToNone) :: Nil
 
     def wasOneOf(sym: Symbol, flags: FlagSet) =
-      ctx.atPhase(thisPhase) { sym.isOneOf(flags) }
+      atPhase(thisPhase) { sym.isOneOf(flags) }
 
     def traitInits(mixin: ClassSymbol): List[Tree] = {
       val argsIt = superCallsAndArgs.get(mixin) match
diff --git a/compiler/src/dotty/tools/dotc/transform/MixinOps.scala b/compiler/src/dotty/tools/dotc/transform/MixinOps.scala
@@ -43,7 +43,7 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
    *  The test is performed at phase `thisPhase`.
    */
   def isCurrent(sym: Symbol): Boolean =
-    ctx.atPhase(thisPhase) {
+    atPhase(thisPhase) {
       cls.info.nonPrivateMember(sym.name).hasAltWith(_.symbol == sym)
     }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -59,7 +59,7 @@ class TreeChecker extends Phase with SymTransformer {
 
   def checkCompanion(symd: SymDenotation)(using Context): Unit = {
     val cur = symd.linkedClass
-    val prev = ctx.atPhase(ctx.phase.prev) {
+    val prev = atPhase(ctx.phase.prev) {
       symd.symbol.linkedClass
     }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/ValueClasses.scala b/compiler/src/dotty/tools/dotc/transform/ValueClasses.scala
@@ -22,7 +22,7 @@ object ValueClasses {
   }
 
   def isMethodWithExtension(sym: Symbol)(using Context): Boolean =
-    ctx.atPhaseNotLaterThan(ctx.extensionMethodsPhase) {
+    atPhaseNotLaterThan(ctx.extensionMethodsPhase) {
       val d = sym.denot
       d.validFor.containsPhaseId(summon[Context].phaseId) &&
       d.isRealMethod &&
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -451,7 +451,7 @@ object RefChecks {
 
       def hasJavaErasedOverriding(sym: Symbol): Boolean =
         !ctx.erasurePhase.exists || // can't do the test, assume the best
-          ctx.atPhase(ctx.erasurePhase.next) {
+          atPhase(ctx.erasurePhase.next) {
             clazz.info.nonPrivateMember(sym.name).hasAltWith { alt =>
               alt.symbol.is(JavaDefined, butNot = Deferred) &&
                 !sym.owner.derivesFrom(alt.symbol.owner) &&
diff --git a/compiler/src/dotty/tools/repl/ReplDriver.scala b/compiler/src/dotty/tools/repl/ReplDriver.scala
@@ -4,7 +4,7 @@ import java.io.{File => JFile, PrintStream}
 
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.ast.{tpd, untpd}
-import dotty.tools.dotc.core.Contexts.{Context, ctx, inContext}
+import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Denotations.Denotation
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Mode
@@ -320,7 +320,7 @@ class ReplDriver(settings: Array[String],
           rendering.renderTypeDef(x)
       }
 
-    ctx.atPhase(ctx.typerPhase.next) {
+    atPhase(ctx.typerPhase.next) {
       // Display members of wrapped module:
       tree.symbol.info.memberClasses
         .find(_.symbol.name == newestWrapper.moduleClassName)
diff --git a/compiler/test/dotty/tools/AnnotationsTests.scala b/compiler/test/dotty/tools/AnnotationsTests.scala
@@ -25,7 +25,7 @@ class AnnotationsTest:
         val annotCls = ctx.requiredClass("Annot")
         val arrayOfString = defn.ArrayType.appliedTo(List(defn.StringType))
 
-        ctx.atPhase(ctx.erasurePhase.next) {
+        atPhase(ctx.erasurePhase.next) {
           val annot = cls.getAnnotation(annotCls)
           // Even though we're forcing the annotation after erasure,
           // the typed trees should be unerased, so the type of
diff --git a/compiler/test/dotty/tools/SignatureTest.scala b/compiler/test/dotty/tools/SignatureTest.scala

Original file line number	Diff line number	Diff line change
`@@ -160,7 +160,7 @@ object DottyBackendInterface {`
`160`	`160`	`*/`
`161`	`161`	`def isTopLevelModuleClass(using Context): Boolean =`
`162`	`162`	`sym.is(ModuleClass) &&`
`163`		`- ctx.atPhase(ctx.flattenPhase) {`
	`163`	`+ atPhase(ctx.flattenPhase) {`
`164`	`164`	`toDenot(sym).owner.is(PackageClass)`
`165`	`165`	`}`
`166`	`166`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ object JSInterop {`
`16`	`16`	`/** Is this symbol a JavaScript type? */`
`17`	`17`	`def isJSType(sym: Symbol)(using Context): Boolean = {`
`18`	`18`	`//sym.hasAnnotation(jsdefn.RawJSTypeAnnot)`
`19`		`- ctx.atPhase(ctx.erasurePhase) {`
	`19`	`+ atPhase(ctx.erasurePhase) {`
`20`	`20`	`sym.derivesFrom(jsdefn.JSAnyClass)`
`21`	`21`	`}`
`22`	`22`	`}`
`@@ -32,7 +32,7 @@ object JSInterop {`
`32`	`32`	* much as accessor methods created for `val`s and `var`s.
`33`	`33`	`*/`
`34`	`34`	`def isJSGetter(sym: Symbol)(using Context): Boolean = {`
`35`		`- sym.info.firstParamTypes.isEmpty && ctx.atPhase(ctx.erasurePhase) {`
	`35`	`+ sym.info.firstParamTypes.isEmpty && atPhase(ctx.erasurePhase) {`
`36`	`36`	`sym.info.isParameterless`
`37`	`37`	`}`
`38`	`38`	`}`