Factorize code to know what to inline from inline trait

Author: timotheeandres

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -23,6 +23,7 @@ import NamerOps._
 import ContextOps._
 import Variances.Invariant
 import TastyUnpickler.NameTable
+import typer.Typer
 import typer.ConstFold
 import typer.Checking.checkNonCyclic
 import typer.Nullables._
@@ -1063,11 +1064,7 @@ class TreeUnpickler(reader: TastyReader,
 
             val fork = forkAt(statsStart)
             val stats = fork.readIndexedStats(localDummy, end)
-            val inlinedMembers = (tparams ++ vparams ++ stats).filter { stat =>
-              !(stat.isInstanceOf[TypeDef] && cls.typeParams.contains(stat.symbol)) // !isConstructor
-              && !stat.symbol.is(Deferred)
-              && !stat.symbol.isAllOf(Inline)
-            }
+            val inlinedMembers = (tparams ++ vparams ++ stats).filter(member => Typer.isInlineableFromInlineTrait(cls, member))
             Block(inlinedMembers, unitLiteral).withSpan(cls.span)
           }
         })

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

@@ -108,6 +108,11 @@ object Typer {
   def rememberSearchFailure(tree: tpd.Tree, fail: SearchFailure) =
     tree.putAttachment(HiddenSearchFailure,
       fail :: tree.attachmentOrElse(HiddenSearchFailure, Nil))
+
+  def isInlineableFromInlineTrait(inlinedTraitSym: ClassSymbol, member: tpd.Tree)(using Context): Boolean =
+    !(member.isInstanceOf[tpd.TypeDef] && inlinedTraitSym.typeParams.contains(member.symbol))
+    && !member.symbol.is(Deferred)
+    && !member.symbol.isAllOf(Inline)
 }
 /** Typecheck trees, the main entry point is `typed`.
  *
@@ -2662,13 +2667,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       val body1 = addAccessorDefs(cls, typedStats(impl.body, dummy)(using ctx.inClassContext(self1.symbol))._1) ::: inlineTraitDefs
 
       if !ctx.isAfterTyper && cls.isInlineTrait then
-        def isConstructorType(t: Tree) = t.isInstanceOf[TypeDef] && cls.typeParams.contains(t.symbol)
-        // If the following is changed, remember to adapt TreeUnpickler.scala as well
-        val membersToInline = body1.filter { t =>
-          !isConstructorType(t)
-          && !t.symbol.is(Deferred)
-          && !t.symbol.isAllOf(Inline)
-        }
+        val membersToInline = body1.filter(member => isInlineableFromInlineTrait(cls, member))
         val wrappedMembersToInline = Block(membersToInline, unitLiteral).withSpan(cdef.span)
         PrepareInlineable.registerInlineInfo(cls, wrappedMembersToInline)