Faster type avoidance

The probability that the type of a block refers to a local symbol is
low:

- type definitions are usually inside classes, objects or packages
- avoidance is also called from TreeCopier after typer, it's even rare
  to refer to local symbols in such scenarios

Therefore, we can have a fast check to see whether the type refers
to any local definitions

Author: liufengyun

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

@@ -5724,6 +5724,36 @@ object Types {
             foldOver(xs, tp)
   end NamedPartsAccumulator
 
+  class ExistsLocalRef(using Context) extends TypeAccumulator[Boolean]:
+    val locals = util.HashSet[Type]()
+    def apply(exists: Boolean, tp: Type): Boolean =
+      exists || tp.match {
+        case tp: NamedType =>
+          this(false, tp.prefix)
+        case NoPrefix =>
+          true
+        case tp: AppliedType =>
+          foldOver(false, tp)
+        case TypeBounds(lo, hi) =>
+          this(this(false, lo), hi)
+        case tp: ParamRef =>
+          !locals.contains(tp)
+        case tp: ConstantType =>
+          false
+        case tp: ThisType =>
+          false
+        case tl: HKTypeLambda =>
+          locals ++= tl.paramRefs
+          foldOver(false, tl)
+        case tp: RecThis =>
+          false
+        case tp: LazyRef =>
+          false
+        case _ =>
+          foldOver(false, tp)
+      }
+  end ExistsLocalRef
+
   class isGroundAccumulator(using Context) extends TypeAccumulator[Boolean] {
     def apply(x: Boolean, tp: Type): Boolean = x && {
       tp match {

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

@@ -41,7 +41,11 @@ trait TypeAssigner {
   }
 
   def avoidingType(expr: Tree, bindings: List[Tree])(using Context): Type =
-    TypeOps.avoid(expr.tpe, localSyms(bindings).filterConserve(_.isTerm))
+    val refersLocal = ExistsLocalRef()(false, expr.tpe)
+    if refersLocal then
+      TypeOps.avoid(expr.tpe, localSyms(bindings).filterConserve(_.isTerm))
+    else
+      expr.tpe
 
   def avoidPrivateLeaks(sym: Symbol)(using Context): Type =
     if sym.owner.isClass && !sym.isOneOf(JavaOrPrivateOrSynthetic)

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

@@ -1007,7 +1007,11 @@ class Typer extends Namer
       case _ =>
         Typed(tree, TypeTree(pt.simplified))
     }
-    def noLeaks(t: Tree): Boolean = escapingRefs(t, localSyms).isEmpty
+
+    def noLeaks(t: Tree): Boolean =
+      val refersLocal = ExistsLocalRef()(false, tree.tpe)
+      !refersLocal || escapingRefs(t, localSyms).isEmpty
+
     if (noLeaks(tree)) tree
     else {
       fullyDefinedType(tree.tpe, "block", tree.span)

compiler/test/dotc/pos-test-pickling.blacklist

@@ -61,3 +61,5 @@ i9793.scala
 # lazy_implicit symbol has different position after pickling
 i8182.scala
 
+# trivial recursive type gets stripped
+i11464.scala