add hasSpecializations property to CompilationUnits

This commit adds a new field to the CompilationUnit to check whether
the unit contains an inline trait. This property is then used by
inline trait specific passes to determine whether or not they need to
run.

Author: jmesyou

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -57,6 +57,12 @@ class CompilationUnit protected (val source: SourceFile, val info: CompilationUn
    */
   var needsInlining: Boolean = false
 
+  /** Set to `true` if there are inline traits (with or without Specialized context bounds)
+   *  This is used by:
+   *  DesugarSpecializedTraits, SpecializeInlineTraits, PruneInlinedMethods, PruneInlineTraits
+   */
+  var hasSpecializations: Boolean = false
+
   var hasMacroAnnotations: Boolean = false
 
   def hasUnrollDefs: Boolean = unrolledClasses.nonEmpty

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

@@ -353,74 +353,6 @@ class DesugarSpecializedTraits extends MiniPhase, IdentityDenotTransformer:
     // but not sure if that's worth doing (it would be throwing away work).
     (generatedTraitStatsFinal ++ generatedClassStatsFinal ++ stats, specializationsFinal) 
   }
-  
-  private def checkSpecializedTraitRules(tree: Tree)(using Context) =
-    def checkType(t: Type, pos: SrcPos) = t.widen.dealias match {
-      case SpecializedEvidence(_) => 
-        report.error(s"Only inline traits and inline functions may take Specialized type parameters", pos)
-      case _ =>
-    }
-    
-    // TODO: Depending on how we ultimately organize the phasing
-    // If we settle on using miniphases, this could be moved into transformDefDef and transformBlock.
-    tree.foreachSubTree { 
-      case ddef: DefDef if ddef.symbol.isConstructor && !ddef.symbol.owner.is(Flags.Inline) => 
-        ddef.paramss.flatten.foreach(p => checkType(p.tpe, ddef.srcPos))
-      case ddef: DefDef if !ddef.symbol.isConstructor && !ddef.symbol.is(Flags.Inline) => 
-        ddef.paramss.flatten.foreach(p => checkType(p.tpe, ddef.srcPos))
-      case AnonymousClassInstance(anon) =>
-        def deandify(tp: Type): Iterator[Type] = tp match {
-          case AndType(l, r) => deandify(l) ++ deandify(r)
-          case _ => Iterator.single(tp)
-        }
-        anon.typeTree.tpe match {
-          case a: AndType => /* Multiple mixed in traits will be typed as an AndType */ 
-            deandify(a) foreach {trt =>
-              Specialization.unapply(trt, anon.typeTree.span) foreach { spec => 
-                if spec.hasSpecializedParams then
-                  report.error(
-                    """
-                    Anonymous classes acting as instances of Specialized traits may not mix in other traits; 
-                    You can make a named object instead if you like.
-                    """, 
-                    anon.srcPos
-                  )
-              }
-            }
-      
-          case tpe =>
-            Specialization.unapply(tpe, anon.typeTree.span).map(spec => 
-                {
-                if spec.hasSpecializedParams then
-                  // Only allowed to contain evidence parameters
-                  if anon.body.filterNot(x => x.symbol.name.is(ContextBoundParamName)).nonEmpty then 
-                    report.error(
-                      """
-                      Anonymous classes acting as instances of Specialized traits may not have additional members; 
-                      you can make a named object instead if you like.
-                      """,
-                      anon.srcPos
-                    )                    
-
-                  anon.parentCalls match { 
-                    case (obj :: parentsOfSpecTrait) :+ (app@Apply(_, _)) 
-                      if (obj.symbol.owner == ctx.definitions.ObjectClass) && 
-                        (parentsOfSpecTrait.forall(x => spec.symbol.asClass.baseClasses.exists(p => p == x.symbol.owner))) => 
-                    case _ => 
-                      report.error(
-                        """
-                        Anonymous classes acting as instances of Specialized traits may not mix in other traits; 
-                        you can make a named object instead if you like.""", 
-                        anon.srcPos
-                      )
-                  }
-                else
-                  tree
-              }).getOrElse(tree)
-        }
-
-      case _ =>
-    }
 
   private def specializedTraitCtx(using Context): Context = 
     ctx.fresh.setInlineTraitState(ctx.inlineTraitState.copyInPhase(InlineTraitState.InlineContext.SpecializedTraits))
@@ -439,10 +371,9 @@ class DesugarSpecializedTraits extends MiniPhase, IdentityDenotTransformer:
   // As long as we remember to call transformFollowing on the synthetic classes (which we do) then 
   // we should be composable in the way that we want to be.
   override def transformUnit(tree: Tree)(using Context): Tree = 
-    tree match {
+    if !ctx.compilationUnit.hasSpecializations then tree 
+    else tree match {
       case pkg@PackageDef(pid, stats) =>
-        checkSpecializedTraitRules(tree)
-
         val (stats1, specializedTraitCache2) = transformStatements(stats, specializedTraitCache)
 
         specializedTraitCache = specializedTraitCache2 

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

@@ -315,6 +315,85 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
     private def checkInlTraitPrivateMemberIsLocal(tree: Tree)(using Context): Unit =
       if tree.symbol.owner.isInlineTrait && tree.symbol.isAllOf(Private, butNot = Local) then
         report.error(em"implementation restriction: inline traits cannot have non-local private members. This also means no retained inline methods.", tree.srcPos)
+    
+    private def checkFunctionContextBounds(ddef: DefDef)(using Context): Unit = {
+      val symbol = ddef.symbol 
+
+      val isConstructorOfNonInlineType = ddef.symbol.isConstructor && !ddef.symbol.owner.is(Flags.Inline)
+      val isRegularDefDef = !ddef.symbol.isConstructor && !ddef.symbol.is(Flags.Inline) 
+      if isConstructorOfNonInlineType || isRegularDefDef then
+        ddef.paramss.flatten.foreach {
+          param => if SpecializedEvidence.unapply(param.tpe.widen.dealias).nonEmpty then 
+            report.error(s"Only inline traits and inline functions may take Specialized type parameters", param.srcPos)
+
+        }
+    }
+
+    private def checkForIllegalUseOfSpecialized(tdef: TypeDef)(using Context): Unit = {
+      val containUseOfSpecialized = 
+        tdef.rhs.tpe.existsPart(t => t.typeSymbol == defn.SpecializedClass.asType) 
+      if containUseOfSpecialized && (tdef.symbol ne defn.SpecializedClass)then
+        report.error(IllegalUseOfSpecialized(), tdef.srcPos)
+    }
+
+    private def checkValidAnonymousSpecialization(tree: Block)(using Context): Unit = tree match {
+      case AnonymousClassInstance(anon) =>
+        def deandify(tp: Type): Iterator[Type] = tp match {
+          case AndType(l, r) => deandify(l) ++ deandify(r)
+          case _ => Iterator.single(tp)
+        }
+        anon.typeTree.tpe match {
+          case a: AndType => /* Multiple mixed in traits will be typed as an AndType */ 
+            deandify(a) foreach {
+              Specialization.unapply(_, anon.typeTree.span) foreach {
+                spec => if spec.hasSpecializedParams then
+                  report.error(
+                    """
+                    Anonymous classes acting as instances of Specialized traits may not mix in other traits; 
+                    You can make a named object instead if you like.
+                    """, 
+                    anon.srcPos
+                  )
+                }
+              }
+          
+          case tpe =>
+            Specialization
+              .unapply(tpe, anon.typeTree.span)
+              .foreach(spec => 
+                if spec.hasSpecializedParams then
+                  // Only allowed to contain evidence parameters
+                  if anon.body.filterNot(x => x.symbol.name.is(ContextBoundParamName)).nonEmpty then 
+                    report.error(
+                      """
+                      Anonymous classes acting as instances of Specialized traits may not have additional members; 
+                      you can make a named object instead if you like.
+                      """,
+                      anon.srcPos
+                    )                    
+
+                  def hasOnlyValidParents: Boolean = anon.parentCalls match { 
+                    case (obj :: parentsOfSpecTrait) :+ (app@Apply(_, _)) =>
+                      val isFirstParentObject = obj.symbol.owner == ctx.definitions.ObjectClass
+                      val validOtherParents =
+                        parentsOfSpecTrait.forall(x => spec.symbol.asClass.baseClasses.exists(p => p == x.symbol.owner))
+                      
+                      isFirstParentObject && validOtherParents
+                    case _ => false
+                  }
+                      
+                  if !hasOnlyValidParents then
+                    report.error(
+                      """
+                      Anonymous classes acting as instances of Specialized traits may not mix in other traits; 
+                      you can make a named object instead if you like.""", 
+                      anon.srcPos
+                    )
+                )
+        }
+      case _ =>
+    }
+
 
     private def transformSelect(tree: Select, targs: List[Tree])(using Context): Tree = {
       val qual = tree.qualifier
@@ -581,6 +660,7 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
             if tree.symbol == defn.SpecializedModule && (ctx.owner ne defn.SpecializedModule.moduleClass) then
               report.error(IllegalUseOfSpecialized(), tree.srcPos)
             registerNeedsInlining(tree)
+            registerIfHasSpecializations(tree)
             val tree1 = checkUsableAsValue(tree)
             tree1.tpe match {
               case tpe: ThisType => This(tpe.cls).withSpan(tree.span)
@@ -678,14 +758,13 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
         case tree: DefDef =>
           registerIfHasMacroAnnotations(tree)
           Checking.checkPolyFunctionType(tree.tpt)
+          checkFunctionContextBounds(tree)
           annotateContextResults(tree)
           val tree1 = cpy.DefDef(tree)(tpt = explicifyTpt(tree))
           processValOrDefDef(superAcc.wrapDefDef(tree1)(super.transform(tree1).asInstanceOf[DefDef]))
         case tree: TypeDef =>
-          if tree.symbol.isInlineTrait then
-            ctx.compilationUnit.needsInlining = true  // Check and transform inline traits
-          if tree.rhs.tpe.existsPart(t => t.typeSymbol == defn.SpecializedClass.asType) && (tree.symbol ne defn.SpecializedClass) then
-            report.error(IllegalUseOfSpecialized(), tree.srcPos)
+          registerIfHasSpecializations(tree)
+          checkForIllegalUseOfSpecialized(tree)
           registerIfHasMacroAnnotations(tree)
           val sym = tree.symbol
           if (sym.isClass)
@@ -696,9 +775,8 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
               sym.keepAnnotationsCarrying(thisPhase, Set(defn.CompanionClassMetaAnnot), orNoneOf = defn.MetaAnnots)
             tree.rhs match
               case impl: Template =>
+                registerIfHasSpecializations(impl)
                 for parent <- impl.parents do
-                  if Inlines.symbolFromParent(parent).isInlineTrait then
-                    ctx.compilationUnit.needsInlining = true
                   Checking.checkTraitInheritance(parent.tpe.classSymbol, sym.asClass, parent.srcPos)
                   // Constructor parameters are in scope when typing a parent.
                   // While they can safely appear in a parent tree, to preserve
@@ -789,6 +867,9 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
           )
         case Block(_, Closure(_, _, tpt)) if ExpandSAMs.needsWrapperClass(tpt.tpe) =>
           superAcc.withInvalidCurrentClass(super.transform(tree))
+        case block: Block => 
+          checkValidAnonymousSpecialization(block)
+          super.transform(tree)
         case tree: RefinedTypeTree =>
           Checking.checkPolyFunctionType(tree)
           super.transform(tree)
@@ -814,6 +895,18 @@ class PostTyper extends MacroTransform with InfoTransformer { thisPhase =>
       if tree.symbol.is(Inline) && !Inlines.inInlineMethod && !ctx.mode.is(Mode.NoInline) then
         ctx.compilationUnit.needsInlining = true
 
+    private def registerIfHasSpecializations(tree: Tree)(using Context): Unit = { 
+      val hasSpecializations = tree match
+        case tree: Ident    => tree.symbol == defn.SpecializedModule_apply
+        case tree: TypeDef  => tree.symbol.isInlineTrait
+        case tree: Template => tree.parents.exists(parent => Inlines.symbolFromParent(parent).isInlineTrait)
+        case _ => false 
+
+      if hasSpecializations then 
+        ctx.compilationUnit.needsInlining = true
+        ctx.compilationUnit.hasSpecializations = true
+    }
+
     /** Check if the definition has macro annotation and sets `compilationUnit.hasMacroAnnotations` if needed. */
     private def registerIfHasMacroAnnotations(tree: DefTree)(using Context) =
       if !Inlines.inInlineMethod && tree.symbol.hasMacroAnnotation then

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

@@ -32,22 +32,23 @@ class PruneInlineTraits extends MiniPhase with SymTransformer { thisTransform =>
     else sym
 
   override def transformTemplate(tree: Template)(using Context): Tree = 
-    cpy.Template(tree)(body = tree.body.flatMap({
+    if !ctx.compilationUnit.hasSpecializations then tree 
+    else cpy.Template(tree)(body = tree.body.flatMap({
       case stmt: ValDef if isEraseable(stmt.symbol) => Some(cpy.ValDef(stmt)(rhs = EmptyTree))
       case stmt: DefDef if isEraseable(stmt.symbol) => Some(cpy.DefDef(stmt)(rhs = EmptyTree))
       case stmt: (ValDef | DefDef) if isDeletable(stmt.symbol) => None
       case stmt => Some(stmt)
     }))
 
   private def isEraseable(sym: SymDenotation)(using Context): Boolean =
-    !sym.isType
+    sym.exists
+    && sym.owner.isInlineTrait
+    && !sym.isType
     && !sym.isConstructor
     && !sym.is(Param)
     && !sym.is(ParamAccessor)
     && !sym.is(Local)
     && !sym.isLocalDummy
-    && sym.exists
-    && sym.owner.isInlineTrait
 
   private def isDeletable(sym: SymDenotation)(using Context): Boolean = 
     !sym.isType

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

@@ -20,19 +20,24 @@ class PruneInlinedMethods extends MiniPhase with InfoTransformer { thisTransform
 
   override def description: String = PruneInlinedMethods.description
 
-  override def transformInfo(tp: Type, sym: Symbol)(using Context) = tp match {
-    case clsInfo: ClassInfo if sym.isClass && !sym.is(Package) && !sym.is(JavaDefined) => 
-      clsInfo.derivedClassInfo(decls =
-          clsInfo.decls.filteredScope(!isDeletable(_))
-      )
-    case _ => tp
+  override def transformInfo(tp: Type, sym: Symbol)(using Context) = 
+    if !ctx.compilationUnit.hasSpecializations then tp 
+    else tp match {
+      case clsInfo: ClassInfo if sym.isClass && !sym.is(Package) && !sym.is(JavaDefined) => 
+        clsInfo.derivedClassInfo(decls =
+            clsInfo.decls.filteredScope(!isDeletable(_))
+        )
+      case _ => tp
   }
 
   override def transformTemplate(tree: Template)(using Context): Tree = 
-    cpy.Template(tree)(body = tree.body.flatMap({
-      case stmt: DefDef if isDeletable(stmt.symbol) => None
-      case stmt => Some(stmt)
-    }))
+    if !ctx.compilationUnit.hasSpecializations then tree 
+    else cpy.Template(tree)(
+      body = tree.body.flatMap {
+        case stmt: DefDef if isDeletable(stmt.symbol) => None
+        case stmt => Some(stmt)
+      }
+    )
 
   private def isDeletable(sym: Symbol)(using Context): Boolean = 
     Specialization.isSpecializedMethod(sym)

tests/run/i3000b.check

@@ -1,2 +1,2 @@
-Foo$$anon$2
-bar.Bar$$anon$1
+Foo$$anon$1
+bar.Bar$$anon$2