Introduce bindTypeSymbols utility in tpd.TreeOps

Author: dwijnand

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

@@ -1137,6 +1137,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     /** Replace Ident nodes references to the underlying tree that defined them */
     def underlying(using Context): Tree = MapToUnderlying().transform(tree)
 
+    /** Collect all the TypeSymbol's of the type Bind nodes in the tree. */
+    def bindTypeSymbols(using Context): List[TypeSymbol] =
+      tree.collectSubTrees { case b: Bind if b.isType => b.symbol.asType }
+
     // --- Higher order traversal methods -------------------------------
 
     /** Apply `f` to each subtree of this tree */

compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala

@@ -216,31 +216,21 @@ class InlineReducer(inliner: Inliner)(using Context):
       type TypeBindsMap = SimpleIdentityMap[TypeSymbol, java.lang.Boolean]
 
       def getTypeBindsMap(pat: Tree, tpt: Tree): TypeBindsMap = {
-        val getBinds = new TreeAccumulator[Set[TypeSymbol]] {
-          def apply(syms: Set[TypeSymbol], t: Tree)(using Context): Set[TypeSymbol] = {
-            val syms1 = t match {
-              case t: Bind if t.symbol.isType =>
-                syms + t.symbol.asType
-              case _ => syms
-            }
-            foldOver(syms1, t)
-          }
-        }
-
         // Extractors can contain Bind nodes in type parameter lists,
         // for that case tree looks like this:
         //   UnApply[t @ t](pats)(implicits): T[t]
         // Test case is pos/inline-caseclass.scala.
+        //
         // Alternatively, for explicitly specified type binds in type annotations like in
         //   case A(B): A[t]
         // the tree will look like this:
         //   Unapply[t](pats)(implicits) : T[t @ t]
         // and the binds will be found in the type tree instead
         // Test case is pos-macros/i15971
-        val tptBinds = getBinds(Set.empty[TypeSymbol], tpt)
+        val tptBinds = tpt.bindTypeSymbols.toSet
         val binds: Set[TypeSymbol] = pat match {
           case UnApply(TypeApply(_, tpts), _, _) =>
-            getBinds(Set.empty[TypeSymbol], tpts) ++ tptBinds
+            tpts.flatMap(_.bindTypeSymbols).toSet ++ tptBinds
           case _ => tptBinds
         }
 

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

@@ -429,13 +429,7 @@ trait TypeAssigner {
   def assignType(tree: untpd.CaseDef, pat: Tree, body: Tree)(using Context): CaseDef = {
     val ownType =
       if (body.isType) {
-        val getParams = new TreeAccumulator[mutable.ListBuffer[TypeSymbol]] {
-          def apply(ps: mutable.ListBuffer[TypeSymbol], t: Tree)(using Context) = t match {
-            case t: Bind if t.symbol.isType => foldOver(ps += t.symbol.asType, t)
-            case _ => foldOver(ps, t)
-          }
-        }
-        val params1 = getParams(new mutable.ListBuffer[TypeSymbol](), pat).toList
+        val params1 = pat.bindTypeSymbols
         val params2 = pat.tpe match
           case AppliedType(tycon, args) =>
             val tparams = tycon.typeParamSymbols