Reduce context creations for value class related ops

Author: odersky

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

@@ -857,7 +857,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
 
     /** After phase `trans`, set the owner of every definition in this tree that was formerly
-     *  owner by `from` to `to`.
+     *  owned by `from` to `to`.
      */
     def changeOwnerAfter(from: Symbol, to: Symbol, trans: DenotTransformer)(using Context): ThisTree =
       if (ctx.phase == trans.next) {

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

@@ -796,7 +796,7 @@ object Contexts {
     changeOwnersInUse += 1
     nestedCtx.setOwner(owner).setTyperState(ctx.typerState)
 
-  /** Run `op` in current context, with a mode is temporarily set as specified.
+  /** Run `op` in current context, in a reusable context that has the specified owner.
    */
   inline def runWithOwner[T](owner: Symbol)(inline op: Context ?=> T)(using Context): T =
     if Config.reuseOwnerContexts then

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

@@ -848,13 +848,8 @@ object SymDenotations {
     def isSerializable(using Context): Boolean =
       isClass && derivesFrom(defn.JavaSerializableClass)
 
-    /** Is this symbol a class that extends `AnyVal`? */
-    final def isValueClass(using Context): Boolean =
-      val di = initial
-      di.isClass
-      && atPhase(di.validFor.firstPhaseId)(di.derivesFrom(defn.AnyValClass))
-        // We call derivesFrom at the initial phase both because AnyVal does not exist
-        // after Erasure and to avoid cyclic references caused by forcing denotations
+    /** Is this symbol a class that extends `AnyVal`? Overridden in ClassDenotation */
+    def isValueClass(using Context): Boolean = false
 
     /** Is this symbol a class of which `null` is a value? */
     final def isNullableClass(using Context): Boolean =
@@ -2006,6 +2001,17 @@ object SymDenotations {
     /** Hook to do a pre-enter test. Overridden in PackageDenotation */
     protected def proceedWithEnter(sym: Symbol, mscope: MutableScope)(using Context): Boolean = true
 
+    final override def isValueClass(using Context): Boolean =
+      val di = initial.asClass
+      val anyVal = defn.AnyValClass
+      if di.baseDataCache.isValid && !ctx.erasedTypes then
+        // fast path that does not demand time travel
+        (symbol eq anyVal) || di.baseClassSet.contains(anyVal)
+      else
+        // We call derivesFrom at the initial phase both because AnyVal does not exist
+        // after Erasure and to avoid cyclic references caused by forcing denotations
+        atPhase(di.validFor.firstPhaseId)(di.derivesFrom(anyVal))
+
     /** Enter a symbol in current scope, and future scopes of same denotation.
      *  Note: We require that this does not happen after the first time
      *  someone does a findMember on a subclass.

compiler/src/dotty/tools/dotc/transform/ValueClasses.scala

@@ -22,15 +22,13 @@ object ValueClasses {
   }
 
   def isMethodWithExtension(sym: Symbol)(using Context): Boolean =
-    atPhaseNoLater(extensionMethodsPhase) {
-      val d = sym.denot
-      d.validFor.containsPhaseId(ctx.phaseId) &&
-      d.isRealMethod &&
-      isDerivedValueClass(d.owner) &&
-      !d.isConstructor &&
-      !d.symbol.isSuperAccessor &&
-      !d.is(Macro)
-    }
+    val d = sym.denot.initial
+    d.validFor.firstPhaseId <= extensionMethodsPhase.id
+    && d.isRealMethod
+    && isDerivedValueClass(d.owner)
+    && !d.isConstructor
+    && !d.symbol.isSuperAccessor
+    && !d.is(Macro)
 
   /** The member of a derived value class that unboxes it. */
   def valueClassUnbox(cls: ClassSymbol)(using Context): Symbol =

tests/pos/visitors.scala

@@ -0,0 +1,5 @@
+object test {
+
+  def f() = 5;
+
+}