Don't run migration operations in ReTypers

Author: odersky

compiler/src/dotty/tools/dotc/typer/Migrations.scala

@@ -20,18 +20,20 @@ import reporting.*
 import NameKinds.ContextBoundParamName
 import rewrites.Rewrites.patch
 import util.Spans.Span
+import rewrites.Rewrites
 
-/** A utility module containing source-dependent deprecation messages
- *  and migrations
+/** A utility trait containing source-dependent deprecation messages
+ *  and migrations.
  */
-object Migrations:
+trait Migrations:
+  this: Typer =>
 
   import tpd.*
 
   /** Flag & migrate `?` used as a higher-kinded type parameter
    *  Warning in 3.0-migration, error from 3.0
    */
-  def migrateKindProjectorQMark(tree: untpd.TypeDef, sym: Symbol)(using Context): Unit =
+  def kindProjectorQMark(tree: untpd.TypeDef, sym: Symbol)(using Context): Unit =
     if tree.name eq tpnme.? then
       val addendum = if sym.owner.is(TypeParam)
         then ", use `_` to denote a higher-kinded type parameter"
@@ -40,10 +42,53 @@ object Migrations:
       report.errorOrMigrationWarning(
         em"`?` is not a valid type name$addendum", namePos, MigrationVersion.Scala2to3)
 
+  def typedAsFunction(tree: untpd.PostfixOp, pt: Type)(using Context): Tree = {
+    val untpd.PostfixOp(qual, Ident(nme.WILDCARD)) = tree: @unchecked
+    val pt1 = if (defn.isFunctionNType(pt)) pt else AnyFunctionProto
+    val nestedCtx = ctx.fresh.setNewTyperState()
+    val res = typed(qual, pt1)(using nestedCtx)
+    res match {
+      case closure(_, _, _) =>
+      case _ =>
+        val recovered = typed(qual)(using ctx.fresh.setExploreTyperState())
+        val msg = OnlyFunctionsCanBeFollowedByUnderscore(recovered.tpe.widen, tree)
+        report.errorOrMigrationWarning(msg, tree.srcPos, MigrationVersion.Scala2to3)
+        if MigrationVersion.Scala2to3.needsPatch then
+          // Under -rewrite, patch `x _` to `(() => x)`
+          msg.actions
+            .headOption
+            .foreach(Rewrites.applyAction)
+          return typed(untpd.Function(Nil, qual), pt)
+    }
+    nestedCtx.typerState.commit()
+
+    lazy val (prefix, suffix) = res match {
+      case Block(mdef @ DefDef(_, vparams :: Nil, _, _) :: Nil, _: Closure) =>
+        val arity = vparams.length
+        if (arity > 0) ("", "") else ("(() => ", "())")
+      case _ =>
+        ("(() => ", ")")
+    }
+    def remedy =
+      if ((prefix ++ suffix).isEmpty) "simply leave out the trailing ` _`"
+      else s"use `$prefix<function>$suffix` instead"
+    def rewrite = Message.rewriteNotice("This construct", `3.4-migration`)
+    report.errorOrMigrationWarning(
+      em"""The syntax `<function> _` is no longer supported;
+          |you can $remedy$rewrite""",
+      tree.srcPos,
+      MigrationVersion.FunctionUnderscore)
+    if MigrationVersion.FunctionUnderscore.needsPatch then
+      patch(Span(tree.span.start), prefix)
+      patch(Span(qual.span.end, tree.span.end), suffix)
+
+    res
+  }
+
   /** Flag & migrate explicit normal arguments to parameters coming from context bounds
    *  Warning in 3.4, error in 3.5, rewrite in 3.5-migration.
    */
-  def migrateContextBoundParams(tree: Tree, tp: Type, pt: FunProto)(using Context): Unit =
+  def contextBoundParams(tree: Tree, tp: Type, pt: FunProto)(using Context): Unit =
     def isContextBoundParams = tp.stripPoly match
       case MethodType(ContextBoundParamName(_) :: _) => true
       case _ => false
@@ -58,4 +103,6 @@ object Migrations:
         tree.srcPos, MigrationVersion(`3.4`, `3.5`))
       if sourceVersion.isAtLeast(`3.5-migration`) then
         patch(Span(pt.args.head.span.start), "using ")
-  end migrateContextBoundParams
+  end contextBoundParams
+
+end Migrations

compiler/src/dotty/tools/dotc/typer/ReTyper.scala

@@ -189,4 +189,5 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
   override protected def checkEqualityEvidence(tree: tpd.Tree, pt: Type)(using Context): Unit = ()
   override protected def matchingApply(methType: MethodOrPoly, pt: FunProto)(using Context): Boolean = true
   override protected def typedScala2MacroBody(call: untpd.Tree)(using Context): Tree = promote(call)
+  override protected def migrate[T](migration: => T, disabled: => T = ()): T = disabled
 }

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -43,18 +43,16 @@ import config.Printers.{gadts, typr}
 import config.Feature
 import config.Feature.{sourceVersion, migrateTo3}
 import config.SourceVersion.*
-import rewrites.Rewrites.patch
+import rewrites.Rewrites, Rewrites.patch
 import staging.StagingLevel
 import reporting.*
 import Nullables.*
 import NullOpsDecorator.*
 import cc.CheckCaptures
 import config.Config
 import config.MigrationVersion
-import Migrations.*
 
 import scala.annotation.constructorOnly
-import dotty.tools.dotc.rewrites.Rewrites
 
 object Typer {
 
@@ -128,7 +126,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                with Dynamic
                with Checking
                with QuotesAndSplices
-               with Deriving {
+               with Deriving
+               with Migrations {
 
   import Typer.*
   import tpd.{cpy => _, _}
@@ -159,6 +158,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   // Overridden in derived typers
   def newLikeThis(nestingLevel: Int): Typer = new Typer(nestingLevel)
 
+  // Overridden to do nothing in derived typers
+  protected def migrate[T](migration: => T, disabled: => T = ()): T = migration
+
   /** Find the type of an identifier with given `name` in given context `ctx`.
    *   @param name       the name of the identifier
    *   @param pt         the expected type
@@ -2979,48 +2981,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         else tree1
     }
 
-  def typedAsFunction(tree: untpd.PostfixOp, pt: Type)(using Context): Tree = {
-    val untpd.PostfixOp(qual, Ident(nme.WILDCARD)) = tree: @unchecked
-    val pt1 = if (defn.isFunctionNType(pt)) pt else AnyFunctionProto
-    val nestedCtx = ctx.fresh.setNewTyperState()
-    val res = typed(qual, pt1)(using nestedCtx)
-    res match {
-      case closure(_, _, _) =>
-      case _ =>
-        val recovered = typed(qual)(using ctx.fresh.setExploreTyperState())
-        val msg = OnlyFunctionsCanBeFollowedByUnderscore(recovered.tpe.widen, tree)
-        report.errorOrMigrationWarning(msg, tree.srcPos, MigrationVersion.Scala2to3)
-        if MigrationVersion.Scala2to3.needsPatch then
-          // Under -rewrite, patch `x _` to `(() => x)`
-          msg.actions
-            .headOption
-            .foreach(Rewrites.applyAction)
-          return typed(untpd.Function(Nil, qual), pt)
-    }
-    nestedCtx.typerState.commit()
-
-    lazy val (prefix, suffix) = res match {
-      case Block(mdef @ DefDef(_, vparams :: Nil, _, _) :: Nil, _: Closure) =>
-        val arity = vparams.length
-        if (arity > 0) ("", "") else ("(() => ", "())")
-      case _ =>
-        ("(() => ", ")")
-    }
-    def remedy =
-      if ((prefix ++ suffix).isEmpty) "simply leave out the trailing ` _`"
-      else s"use `$prefix<function>$suffix` instead"
-    def rewrite = Message.rewriteNotice("This construct", `3.4-migration`)
-    report.errorOrMigrationWarning(
-      em"""The syntax `<function> _` is no longer supported;
-          |you can $remedy$rewrite""",
-      tree.srcPos,
-      MigrationVersion.FunctionUnderscore)
-    if MigrationVersion.FunctionUnderscore.needsPatch then
-      patch(Span(tree.span.start), prefix)
-      patch(Span(qual.span.end, tree.span.end), suffix)
-
-    res
-  }
+  override def typedAsFunction(tree: untpd.PostfixOp, pt: Type)(using Context): Tree =
+    migrate(super.typedAsFunction(tree, pt), throw new AssertionError("can't retype a PostfixOp"))
 
   /** Translate infix operation expression `l op r` to
    *
@@ -3138,7 +3100,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             case tree: untpd.TypeDef =>
               // separate method to keep dispatching method `typedNamed` short which might help the JIT
               def typedTypeOrClassDef: Tree =
-                migrateKindProjectorQMark(tree, sym)
+                migrate(kindProjectorQMark(tree, sym))
                 if tree.isClassDef then
                   typedClassDef(tree, sym.asClass)(using ctx.localContext(tree, sym))
                 else
@@ -3814,7 +3776,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       case wtp: MethodOrPoly =>
         def methodStr = methPart(tree).symbol.showLocated
         if matchingApply(wtp, pt) then
-          migrateContextBoundParams(tree, wtp, pt)
+          migrate(contextBoundParams(tree, wtp, pt))
           if needsTupledDual(wtp, pt) then adapt(tree, pt.tupledDual, locked)
           else tree
         else if wtp.isContextualMethod then