Import modifications by Nicolas

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

@@ -1050,10 +1050,27 @@ class TreeUnpickler(reader: TastyReader,
              .map(_.changeOwner(localDummy, constr.symbol)))
         else parents
 
+      val statsStart = currentAddr
       val lazyStats = readLater(end, rdr => {
         val stats = rdr.readIndexedStats(localDummy, end)
         tparams ++ vparams ++ stats
       })
+      if cls.isInlineTrait then
+        cls.addAnnotation(LazyBodyAnnotation { (ctx0: Context) ?=>
+          val ctx1 = localContext(cls)(using ctx0).addMode(Mode.ReadPositions)
+          inContext(sourceChangeContext(Addr(0))(using ctx1)) {
+            // avoids space leaks by not capturing the current context
+
+            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)
+            }
+            Block(inlinedMembers, unitLiteral).withSpan(cls.span)
+          }
+        })
       defn.patchStdLibClass(cls)
       NamerOps.addConstructorProxies(cls)
       setSpan(start,

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

@@ -580,7 +580,7 @@ class Inliner(val call: tpd.Tree)(using Context):
             case thistpe: ThisType =>
               val cls = thistpe.cls
               if cls.isInlineTrait then
-                integrate(This(ctx.owner.asClass), cls)
+                integrate(This(ctx.owner.asClass).withSpan(call.span), cls)
               else thisProxy.get(cls) match {
                 case Some(t) =>
                   val thisRef = ref(t).withSpan(call.span)

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

@@ -3,7 +3,8 @@ package dotc
 package inlines
 
 import ast.*, core.*
-import Flags.*, Symbols.*, Types.*, Decorators.*, Constants.*, Contexts.*
+import Flags.*, Symbols.*, Types.*, Decorators.*, Constants.*, Contexts.*, TypeOps.*
+import Names.Name
 import StdNames.{str, nme, tpnme}
 import transform.SymUtils._
 import typer.*
@@ -471,8 +472,7 @@ object Inlines:
 
     def expandDefs(): List[Tree] =
       val Block(stats, _) = Inlines.bodyToInline(parentSym): @unchecked
-      val s = stats.map(expandStat)
-      s.map(inlined(_)._2)
+      stats.map(expandStat).map(inlined(_)._2)
     end expandDefs
 
     override protected def registerType(tpe: Type): Unit = tpe match {
@@ -483,51 +483,30 @@ object Inlines:
       case _ => super.registerType(tpe)
     }
 
-    private val argsMap: Map[Names.Name, untpd.Tree] =
-      /*
-       * Consider the parent `new A[String](1)("A")` with signature `inline trait A[T](x: Int)(y: T)`.
-       * The `parent` tree is "right-to-left": Apply(Apply(TypeApply(..., String), 1), "A")
-       * The `info` tree is "left-to-right": PolyType(T, ..., MethodType(x, Int, MethodType(y, T, ...)))
-       * This recursive solution goes as deep as possible in the tree, then matches arguments with their
-       * names in a bottom-up fashion.
-       */
-      def rec(tree: Tree, info: Type, acc: Map[Names.Name, untpd.Tree]): (Option[Type], Map[Names.Name, untpd.Tree]) =
-        tree match {
-          case Apply(tree1, args) => rec(tree1, info, acc) match {
-            case (Some(info1), acc1) => info1 match {
-              case MethodTpe(paramNames, _, info2) if paramNames.length == args.length =>
-                (Some(info2), acc1 ++ paramNames.zip(args).toMap)
-              case _ =>
-                report.error(s"mismatch between Apply ${tree.show} and info ${info1}", parent.srcPos)
-                (None, acc1)
-            }
-            case res => res
-          }
-          case TypeApply(tree1, tpes) => rec(tree1, info, acc) match {
-            case (Some(info1), acc1) => info1 match {
-              case PolyType(lambdaParams, info2) if lambdaParams.length == tpes.length =>
-                (Some(info2), acc1)
-              case _ =>
-                report.error(s"mismatch between TypeApply ${tree.show} and info ${info1}", parent.srcPos)
-                (None, acc1)
-            }
-            case res => res
-          }
-          case _ => (Some(info), acc)
-        }
-
-      parent match {
-        case _: GenericApply =>
-          val (remainingInfo, map) = rec(parent, parent.symbol.info, Map.empty)
-          remainingInfo match {
-            case Some(MethodType(paramNames)) =>
-              report.error(s"could not match the following parameters with their values: ${paramNames.map(_.show).mkString(", ")}", parent.srcPos)
-            case _ =>
-          }
-          map
-        case _ => Map.empty
-      }
-    end argsMap
+    private val argsMap: Map[Name, Tree] =
+      def allArgs(tree: Tree): List[List[Tree]] = tree match
+        case Apply(fun, args) => args :: allArgs(fun)
+        case TypeApply(fun, targs) => targs :: allArgs(fun)
+        case AppliedTypeTree(_, targs) => targs :: Nil
+        case _ => Nil
+      def allParams(info: Type): List[List[Name]] = info match
+        case mt: MethodType => mt.paramNames :: allParams(mt.resultType)
+        case pt: PolyType => pt.paramNames :: allParams(pt.resultType)
+        case _ => Nil
+      val info =
+        if parent.symbol.isClass then parent.symbol.primaryConstructor.info
+        else parent.symbol.info
+      allParams(info).flatten.zip(allArgs(parent).reverse.flatten).toMap
+
+    private val substituteTypeParams = new TypeMap {
+      override def apply(t: Type): Type = t match
+        case TypeRef(ths: ThisType, sym: Symbol) if ths.cls == parentSym =>
+          argsMap(sym.name).tpe
+        case t => mapOver(t)
+    }
+    private val substituteTypeParamsInTree = new TreeTypeMap(
+      typeMap = substituteTypeParams
+    )
 
     private def expandStat(stat: untpd.Tree): untpd.Tree =
       val sym = stat.symbol
@@ -537,22 +516,21 @@ object Inlines:
           stat
         case stat: ValDef =>
           val vdef = cloneValDef(stat)
+          vdef.symbol.info = substituteTypeParams(sym.info)
+          if !sym.is(Private) then
+            vdef.symbol.setFlag(Override)
           val vdef1 =
             if sym.is(ParamAccessor) then
               vdef.symbol.resetFlag(ParamAccessor)
               cpy.ValDef(vdef)(rhs = argsMap(sym.name.asTermName))
             else
               vdef
-          if !sym.is(Private) then
-            vdef1.symbol.setFlag(Override)
-          vdef1 // TODO keep rhs? Can we do a single ValOrDefDef case using cloneStat?
+          substituteTypeParamsInTree(vdef1)
         case stat: DefDef =>
           val ddef = cloneDefDef(stat)
-          if !sym.is(Private) then
-            ddef.symbol.setFlag(Override)
-          if sym.is(Mutable) then
-            report.error("implementation restriction: inline traits cannot have mutable variables", stat.srcPos)
-          ddef
+          ddef.symbol.info = substituteTypeParams(sym.info)
+          if !sym.is(Private) then ddef.symbol.setFlag(Override)
+          substituteTypeParamsInTree(ddef)
         case stat @ TypeDef(_, impl: Template) =>
           report.error("inline traits do not handle inner classes yet", stat.srcPos)
           cloneClass(stat, impl)
@@ -574,7 +552,7 @@ object Inlines:
         val inlinedInfo = ClassInfo(prefix, cls, declaredParents, Scopes.newScope, selfInfo) // TODO adapt parents
         clDef.symbol.copy(owner = ctx.owner, info = inlinedInfo, coord = spanCoord(parent.span)).entered.asClass
       val (constr, body) = inContext(ctx.withOwner(inlinedCls)) {
-        (cloneDefDef(impl.constr), impl.body.map(cloneStat))
+        (clonePrimaryConstructorDefDef(impl.constr), impl.body.map(cloneStat))
       }
       tpd.ClassDefWithParents(inlinedCls, constr, impl.parents, body).withSpan(clDef.span) // TODO adapt parents
 
@@ -592,6 +570,10 @@ object Inlines:
         inlinedRhs(ddef.rhs.subst(oldParamSyms, newParamSyms)) // TODO clone local classes?
       tpd.DefDef(inlinedSym.asTerm, rhsFun).withSpan(parent.span)
 
+    private def clonePrimaryConstructorDefDef(ddef: DefDef)(using Context): DefDef =
+      val constr = cloneDefDef(ddef)
+      cpy.DefDef(constr)(tpt = TypeTree(defn.UnitType), rhs = EmptyTree)
+
     private def cloneValDef(vdef: ValDef)(using Context): ValDef =
       val inlinedSym = vdef.symbol.copy(owner = ctx.owner, coord = spanCoord(parent.span)).entered
       tpd.ValDef(inlinedSym.asTerm, inlinedRhs(vdef.rhs)).withSpan(parent.span) // TODO clone local classes?

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

@@ -288,7 +288,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
 
     def setters(mixin: ClassSymbol): List[Tree] =
       val mixinSetters = mixin.info.decls.filter { sym =>
-        sym.isSetter && (!wasOneOf(sym, Deferred) || sym.name.is(TraitSetterName))
+        sym.isSetter && (!wasOneOf(sym, Deferred) || sym.name.is(TraitSetterName)) && !sym.owner.isAllOf(InlineTrait)
       }
       for (setter <- mixinSetters)
       yield transformFollowing(DefDef(mkForwarderSym(setter.asTerm), unitLiteral.withSpan(cls.span)))

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

@@ -502,7 +502,7 @@ object RefChecks {
           overrideError("needs `override` modifier")
       else if (other.is(AbsOverride) && other.isIncompleteIn(clazz) && !member.is(AbsOverride))
         overrideError("needs `abstract override` modifiers")
-      else if member.is(Override) && other.is(Mutable) then
+      else if member.is(Override) && other.is(Mutable) && !other.owner.isAllOf(InlineTrait) then
         overrideError("cannot override a mutable variable")
       else if (member.isAnyOverride &&
         !(member.owner.thisType.baseClasses exists (_ isSubClass other.owner)) &&

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

@@ -2673,10 +2673,14 @@ 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)
-        val inlineTraitMembers = Block(body1.filter(t => !isConstructorType(t)), unitLiteral)
-        PrepareInlineable.registerInlineInfo(cls, inlineTraitMembers)
+        def isConstructorType(t: Tree) = t.isInstanceOf[TypeDef] && cls.typeParams.contains(t.symbol)
+        val membersToInline = body1.filter { t =>
+          !isConstructorType(t)
+          && !t.symbol.is(Deferred)
+          && !t.symbol.isAllOf(Inline)
+        }
+        val wrappedMembersToInline = Block(membersToInline, unitLiteral).withSpan(cdef.span)
+        PrepareInlineable.registerInlineInfo(cls, wrappedMembersToInline)
 
       checkNoDoubleDeclaration(cls)
       val impl1 = cpy.Template(impl)(constr1, parents1, Nil, self1, body1)

tests/pos/inline-trait-body-def-curried-params.scala

@@ -1,9 +1,8 @@
 inline trait A:
-  def x(foo: Int)(bar: Unit) =
-    bar
-    foo
+  def x(foo: Int)(bar: Int) =
+    foo + bar
 
-  def y(foo: Int) = x(foo)
+  def y(foo: Int) = x(foo)(foo)
 
 class B extends A:
-  def f = x
+  def f = x(1)(2)

tests/pos/inline-trait-body-def-lambda.scala

@@ -0,0 +1,5 @@
+inline trait A:
+  def f = (i: Int) => i
+
+class B extends A:
+  def g = f

tests/pos/inline-trait-body-var.scala

@@ -5,4 +5,4 @@ class B extends A:
   def f =
     val old = x
     x += 1
-    old
+    old

tests/pos/inline-trait-multiple-stages-defs/A_1.scala

@@ -0,0 +1,10 @@
+inline trait A(x: Int):
+  def f: Int = 1
+  def g(a: Int): Int = 2
+  def h: Int
+  val i: Int = 3
+  val j: Int
+  var k: Int = 4
+
+  inline val a = 5
+  inline def b(a: Int): Int = 6

tests/pos/inline-trait-multiple-stages-defs/B_2.scala

@@ -0,0 +1,3 @@
+class B extends A(10):
+  def h: Int = 11
+  val j: Int = 12

tests/pos/inline-trait-multiple-stages-generic-defs/A_1.scala

@@ -0,0 +1,9 @@
+inline trait A[T](x: T):
+  def f: T = x
+  def g(a: T): T = a
+  def h: T
+  val i: T = x
+  val j: T
+  var k: T = x
+
+  inline def b(a: T): T = x

tests/pos/inline-trait-multiple-stages-generic-defs/B_2.scala

@@ -0,0 +1,3 @@
+class B extends A[Int](10):
+  def h: Int = 11
+  val j: Int = 12

tests/pos/inline-trait-multiple-stages/A_1.scala

@@ -1,2 +1,2 @@
 inline trait A:
-  val i: Int = 1
+  val i: Int = 1

tests/pos/inline-trait-multiple-stages/B_2.scala

@@ -1 +1 @@
-class B extends A
+class B extends A

tests/pos/inline-trait-signature-generic-inferred-type.scala

@@ -1,5 +1,8 @@
-inline trait A[T](val x: T)
+inline trait A[T](val x: T):
   def f: T = x
 
-class B extends A(1)
-  val y: Int = f
+class B extends A(1):
+  val y: Int = f
+
+class C extends A[Int](1):
+  val z: Int = f