Partially implement inner traits

There are still issues with symbols being changed, but not their types

Author: timotheeandres

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

@@ -26,6 +26,7 @@ object StdNames {
     inline val LOCALDUMMY_PREFIX        = "<local "       // owner of local blocks
     inline val ANON_CLASS               = "$anon"
     inline val ANON_FUN                 = "$anonfun"
+    inline val INLINE_TRAIT_INNER_CLASS_SUFFIX = "$trait"
 
     inline val REPL_SESSION_LINE  = "rs$line$"
     inline val REPL_ASSIGN_SUFFIX = "$assign"

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

@@ -64,21 +64,21 @@ object Inlines:
 
   /** Should call be inlined in this context? */
   def needsInlining(tree: Tree)(using Context): Boolean =
-    val isInlineableInCtx =
+    def isInlineableInCtx =
       StagingLevel.level == 0
       && (
         ctx.phase == Phases.inliningPhase
         || (ctx.phase == Phases.typerPhase && needsTransparentInlining(tree))
       )
       && !ctx.typer.hasInliningErrors
       && !ctx.base.stopInlining
-      && !ctx.owner.isInlineTrait
+      && !ctx.owner.ownersIterator.exists(_.isInlineTrait)
 
     tree match
       case Block(_, expr) =>
         needsInlining(expr)
       case tdef @ TypeDef(_, impl: Template) =>
-        !tdef.symbol.isInlineTrait && impl.parents.map(symbolFromParent).exists(_.isInlineTrait) && isInlineableInCtx
+        impl.parents.map(symbolFromParent).exists(_.isInlineTrait) && isInlineableInCtx
       case _ =>
         isInlineable(tree.symbol) && !tree.tpe.widenTermRefExpr.isInstanceOf[MethodOrPoly] && isInlineableInCtx
 
@@ -571,16 +571,22 @@ object Inlines:
         inlinedValDef(stat, inlinedSym)
       case stat: DefDef =>
         inlinedDefDef(stat, inlinedSym)
-      case stat @ TypeDef(_, impl: Template) =>
-        inlinedClassDef(stat, impl, inlinedSym.asClass)
+      case stat @ TypeDef(_, _: Template) =>
+        inlinedClassDef(stat, inlinedSym.asClass)
       case stat: TypeDef =>
         inlinedTypeDef(stat, inlinedSym)
 
     private def inlinedMember(sym: Symbol)(using Context): Symbol =
       sym.info match {
         case ClassInfo(prefix, cls, declaredParents, scope, selfInfo) =>
-          val inlinedInfo = ClassInfo(prefix, cls, declaredParents, Scopes.newScope, selfInfo) // TODO adapt parents
-          sym.copy(owner = ctx.owner, info = inlinedInfo, coord = spanCoord(parent.span)).entered.asClass
+          val inlinedSym = newClassSymbol(
+            ctx.owner,
+            sym.asType.name,
+            sym.flags | Synthetic,
+            clsSym => ClassInfo(inlinerTypeMap(prefix), clsSym, declaredParents :+ ThisType.raw(ctx.owner.typeRef).select(sym), Scopes.newScope, selfInfo)
+          )
+          inlinedSym.setTargetName(sym.name ++ str.NAME_JOIN ++ ctx.owner.name)
+          inlinedSym
         case _ =>
           var name = sym.name
           var flags = sym.flags | Synthetic
@@ -598,11 +604,13 @@ object Inlines:
             coord = spanCoord(parent.span)).entered
       }
 
-    private def inlinedStat(stat: Tree)(using Context): Tree = stat match {
-      // TODO check if symbols must be copied
-      case tree: DefDef => inlinedDefDef(tree, tree.symbol)
-      case tree: ValDef => inlinedValDef(tree, tree.symbol)
-    }
+    private def inlinedStat(stat: Tree)(using Context): Tree =
+      val inlinedSym = inlinedMember(stat.symbol)
+      stat match {
+        // TODO check if symbols must be copied
+        case tree: DefDef => inlinedDefDef(tree, inlinedSym)
+        case tree: ValDef => inlinedValDef(tree, inlinedSym)
+      }
 
     private def inlinedValDef(vdef: ValDef, inlinedSym: Symbol)(using Context): ValDef =
       val rhs =
@@ -625,14 +633,18 @@ object Inlines:
 
     private def inlinedPrimaryConstructorDefDef(ddef: DefDef)(using Context): DefDef =
       // TODO check if symbol must be copied
-      val constr = inlinedDefDef(ddef, ddef.symbol)
+      val inlinedSym = inlinedMember(ddef.symbol)
+      inlinedSym.resetFlag(Override)
+      val constr = inlinedDefDef(ddef, inlinedSym)
       cpy.DefDef(constr)(tpt = TypeTree(defn.UnitType), rhs = EmptyTree)
 
-    private def inlinedClassDef(clDef: TypeDef, impl: Template, inlinedCls: ClassSymbol)(using Context): Tree =
-      val (constr, body) = inContext(ctx.withOwner(inlinedCls)) {
-        (inlinedPrimaryConstructorDefDef(impl.constr), impl.body.map(inlinedStat))
+    private def inlinedClassDef(clsDef: TypeDef, inlinedSym: ClassSymbol)(using Context): Tree =
+      val TypeDef(_, tmpl: Template) = clsDef: @unchecked
+      val (constr, body) = inContext(ctx.withOwner(inlinedSym)) {
+        (inlinedPrimaryConstructorDefDef(tmpl.constr), tmpl.body.map(inlinedStat))
       }
-      inlined(tpd.ClassDefWithParents(inlinedCls, constr, impl.parents, body))._2.withSpan(clDef.span) // TODO adapt parents
+      val clsDef1 = tpd.ClassDefWithParents(inlinedSym, constr, tmpl.parents :+ This(ctx.owner.asClass).select(clsDef.symbol), body)
+      inlined(clsDef1)._2.withSpan(clsDef.span) // TODO adapt parents
 
     private def inlinedTypeDef(tdef: TypeDef, inlinedSym: Symbol)(using Context): TypeDef =
       tpd.TypeDef(inlinedSym.asType).withSpan(parent.span)

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

@@ -11,13 +11,15 @@ import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.quoted._
 import dotty.tools.dotc.inlines.Inlines
 import dotty.tools.dotc.ast.TreeMapWithImplicits
-import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
+import dotty.tools.dotc.core.DenotTransformers.SymTransformer
 import dotty.tools.dotc.staging.StagingLevel
+import dotty.tools.dotc.core.SymDenotations.SymDenotation
+import dotty.tools.dotc.core.StdNames.str
 
 import scala.collection.mutable.ListBuffer
 
 /** Inlines all calls to inline methods that are not in an inline method or a quote */
-class Inlining extends MacroTransform {
+class Inlining extends MacroTransform, SymTransformer {
 
   import tpd._
 
@@ -58,6 +60,33 @@ class Inlining extends MacroTransform {
       new InliningTreeMap().transform(tree)
   }
 
+  override def transformSym(sym: SymDenotation)(using Context): SymDenotation =
+    if sym.isClass && sym.owner.isInlineTrait && !sym.is(Module) then
+      sym.copySymDenotation(name = sym.name ++ str.INLINE_TRAIT_INNER_CLASS_SUFFIX, initFlags = (sym.flags &~ Final) | Trait)
+    else
+      sym
+
+  def transformInlineClasses(tree: Tree)(using Context): Tree =
+    val tpd.TypeDef(name, tmpl: Template) = tree: @unchecked
+    val body1 = tmpl.body.flatMap {
+      case tdef @ tpd.TypeDef(name, tmpl1: Template) =>
+        val newTrait = cpy.TypeDef(tdef)(name = name ++ str.INLINE_TRAIT_INNER_CLASS_SUFFIX)
+        val newTypeSym = newSymbol(
+          owner = tree.symbol,
+          name = name.asTypeName,
+          flags = tdef.symbol.flags & (Private | Protected),
+          info = Types.TypeBounds.upper(newTrait.symbol.typeRef),
+          privateWithin = tdef.symbol.privateWithin,
+          coord = tdef.symbol.coord,
+          nestingLevel = tdef.symbol.nestingLevel,
+        ).asType
+        List(newTrait, TypeDef(newTypeSym))
+      case member =>
+        List(member)
+    }
+    val tmpl1 = cpy.Template(tmpl)(body = body1)
+    cpy.TypeDef(tree)(name, tmpl1)
+
   private class InliningTreeMap extends TreeMapWithImplicits {
 
     /** List of top level classes added by macro annotation in a package object.
@@ -67,9 +96,12 @@ class Inlining extends MacroTransform {
 
     override def transform(tree: Tree)(using Context): Tree = {
       tree match
+        case tree: TypeDef if tree.symbol.isInlineTrait =>
+          transformInlineClasses(tree)
         case tree: TypeDef if Inlines.needsInlining(tree) =>
           val tree1 = super.transform(tree)
           if tree1.tpe.isError then tree1
+          else if tree1.symbol.isInlineTrait then transformInlineClasses(tree1)
           else Inlines.inlineParentInlineTraits(tree1)
         case tree: MemberDef =>
           if tree.symbol.is(Inline) then tree

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

@@ -340,6 +340,8 @@ object RefChecks {
      * of class `clazz` are met.
      */
     def checkOverride(checkSubType: (Type, Type) => Context ?=> Boolean, member: Symbol, other: Symbol): Unit =
+      def overridesInlineTraitMember = other.owner.ownersIterator.exists(_.isInlineTrait) && member.is(Synthetic)
+
       def memberTp(self: Type) =
         if (member.isClass) TypeAlias(member.typeRef.EtaExpand(member.typeParams))
         else self.memberInfo(member)
@@ -415,12 +417,13 @@ object RefChecks {
 
       def overrideTargetNameError() =
         val otherTargetName = i"@targetName(${other.targetName})"
-        if member.hasTargetName(member.name) then
-          overrideError(i"misses a target name annotation $otherTargetName")
-        else if other.hasTargetName(other.name) then
-          overrideError(i"should not have a @targetName annotation since the overridden member hasn't one either")
-        else
-          overrideError(i"has a different target name annotation; it should be $otherTargetName")
+        if !overridesInlineTraitMember then
+          if member.hasTargetName(member.name) then
+            overrideError(i"misses a target name annotation $otherTargetName")
+          else if other.hasTargetName(other.name) then
+            overrideError(i"should not have a @targetName annotation since the overridden member hasn't one either")
+          else
+            overrideError(i"has a different target name annotation; it should be $otherTargetName")
 
       //Console.println(infoString(member) + " overrides " + infoString(other) + " in " + clazz);//DEBUG
 
@@ -465,7 +468,7 @@ object RefChecks {
         overrideError("cannot be used here - opaque type aliases cannot be overridden")
       else if (!other.is(Deferred) && member.isClass)
         overrideError("cannot be used here - classes can only override abstract types")
-      else if other.isEffectivelyFinal && !(other.owner.isInlineTrait && member.is(Synthetic)) then // (1.2)
+      else if (other.isEffectivelyFinal && !overridesInlineTraitMember) then // (1.2)
         overrideError(i"cannot override final member ${other.showLocated}")
       else if (member.is(ExtensionMethod) && !other.is(ExtensionMethod)) // (1.3)
         overrideError("is an extension method, cannot override a normal method")