Merge type params and term params in DefDef nodes

Author: odersky

compiler/src-bootstrapped/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -260,15 +260,15 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         withDefaultPos(tpd.polyDefDef(symbol.asTerm,
           tparams => vparamss => yCheckedOwners(rhsFn(tparams.map(_.tpe))(vparamss), symbol).getOrElse(tpd.EmptyTree)))
       def copy(original: Tree)(name: String, typeParams: List[TypeDef], paramss: List[List[ValDef]], tpt: TypeTree, rhs: Option[Term]): DefDef =
-        tpd.cpy.DefDef(original)(name.toTermName, typeParams, paramss, tpt, yCheckedOwners(rhs, original.symbol).getOrElse(tpd.EmptyTree))
+        tpd.cpy.DefDef(original)(name.toTermName, tpd.joinParams(typeParams, paramss), tpt, yCheckedOwners(rhs, original.symbol).getOrElse(tpd.EmptyTree))
       def unapply(ddef: DefDef): (String, List[TypeDef], List[List[ValDef]], TypeTree, Option[Term]) =
-        (ddef.name.toString, ddef.typeParams, ddef.paramss, ddef.tpt, optional(ddef.rhs))
+        (ddef.name.toString, ddef.typeParams, ddef.termParamss, ddef.tpt, optional(ddef.rhs))
     end DefDef
 
     given DefDefMethods: DefDefMethods with
       extension (self: DefDef)
-        def typeParams: List[TypeDef] = self.tparams
-        def paramss: List[List[ValDef]] = self.vparamss
+        def typeParams: List[TypeDef] = self.leadingTypeParams // TODO: adapt to multiple type parameter clauses
+        def paramss: List[List[ValDef]] = self.termParamss
         def returnTpt: TypeTree = self.tpt
         def rhs: Option[Term] = optional(self.rhs)
       end extension

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -667,7 +667,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
         val enclosingClass = origSym.owner.asClass
         new TreeTypeMap(
           typeMap = _.substThis(enclosingClass, selfParamRef.symbol.termRef)
-            .subst(dd.vparamss.head.map(_.symbol), regularParamRefs.map(_.symbol.termRef)),
+            .subst(dd.termParamss.head.map(_.symbol), regularParamRefs.map(_.symbol.termRef)),
           treeMap = {
             case tree: This if tree.symbol == enclosingClass => selfParamRef
             case tree => tree
@@ -714,7 +714,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
     def genDefDef(dd: DefDef): Unit = {
       val rhs = dd.rhs
-      val vparamss = dd.vparamss
+      val vparamss = dd.termParamss
       // the only method whose implementation is not emitted: getClass()
       if (dd.symbol eq defn.Any_getClass) { return }
       assert(mnode == null, "GenBCode detected nested method.")

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -1035,7 +1035,7 @@ class JSCodeGen()(using genCtx: Context) {
   private def genMethodWithCurrentLocalNameScope(dd: DefDef): Option[js.MethodDef] = {
     implicit val pos = dd.span
     val sym = dd.symbol
-    val vparamss = dd.vparamss
+    val vparamss = dd.termParamss
     val rhs = dd.rhs
 
     withScopedVars(

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

@@ -130,7 +130,7 @@ object DesugarEnums {
         .withFlags(Private | Synthetic)
 
     val valuesDef =
-      DefDef(nme.values, Nil, Nil, defn.ArrayType.ofRawEnum, valuesDot(nme.clone_))
+      DefDef(nme.values, Nil, defn.ArrayType.ofRawEnum, valuesDot(nme.clone_))
         .withFlags(Synthetic)
 
     val valuesOfBody: Tree =
@@ -142,7 +142,7 @@ object DesugarEnums {
         CaseDef(Literal(Constant(enumValue.name.toString)), EmptyTree, enumValue)
       ) ::: defaultCase :: Nil
       Match(Ident(nme.nameDollar), stringCases)
-    val valueOfDef = DefDef(nme.valueOf, Nil, List(param(nme.nameDollar, defn.StringType) :: Nil),
+    val valueOfDef = DefDef(nme.valueOf, List(param(nme.nameDollar, defn.StringType) :: Nil),
       TypeTree(), valuesOfBody)
         .withFlags(Synthetic)
 
@@ -195,7 +195,7 @@ object DesugarEnums {
       self = EmptyValDef,
       body = fieldMethods
     ).withAttachment(ExtendsSingletonMirror, ()))
-    DefDef(nme.DOLLAR_NEW, Nil,
+    DefDef(nme.DOLLAR_NEW,
         List(List(param(nme.ordinalDollar_, defn.IntType), param(nme.nameDollar, defn.StringType))),
         TypeTree(), creator).withFlags(Private | Synthetic)
   }
@@ -281,13 +281,13 @@ object DesugarEnums {
   private def isJavaEnum(using Context): Boolean = enumClass.derivesFrom(defn.JavaEnumClass)
 
   def ordinalMeth(body: Tree)(using Context): DefDef =
-    DefDef(nme.ordinal, Nil, Nil, TypeTree(defn.IntType), body).withAddedFlags(Synthetic)
+    DefDef(nme.ordinal, Nil, TypeTree(defn.IntType), body).withAddedFlags(Synthetic)
 
   def ordinalMethLit(ord: Int)(using Context): DefDef =
     ordinalMeth(Literal(Constant(ord)))
 
   def fromOrdinalMeth(body: Tree => Tree)(using Context): DefDef =
-    DefDef(nme.fromOrdinal, Nil, (param(nme.ordinal, defn.IntType) :: Nil) :: Nil,
+    DefDef(nme.fromOrdinal, (param(nme.ordinal, defn.IntType) :: Nil) :: Nil,
       rawRef(enumClass.typeRef), body(Ident(nme.ordinal))).withFlags(Synthetic)
 
   /** Expand a module definition representing a parameterless enum case */

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

@@ -102,7 +102,7 @@ object MainProxies {
       val body = Try(call, handler :: Nil, EmptyTree)
       val mainArg = ValDef(nme.args, TypeTree(defn.ArrayType.appliedTo(defn.StringType)), EmptyTree)
         .withFlags(Param)
-      val mainMeth = DefDef(nme.main, Nil, (mainArg :: Nil) :: Nil, TypeTree(defn.UnitType), body)
+      val mainMeth = DefDef(nme.main, (mainArg :: Nil) :: Nil, TypeTree(defn.UnitType), body)
         .withFlags(JavaStatic)
       val mainTempl = Template(emptyConstructor, Nil, Nil, EmptyValDef, mainMeth :: Nil)
       val mainCls = TypeDef(mainFun.name.toTypeName, mainTempl)

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

@@ -206,20 +206,15 @@ abstract class Positioned(implicit @constructorOnly src: SourceFile) extends Src
     this match {
       case tree: DefDef if tree.name == nme.CONSTRUCTOR && tree.mods.is(JavaDefined) =>
         // Special treatment for constructors coming from Java:
-        // Leave out tparams, they are copied with wrong positions from parent class
+        // Leave out leading type params, they are copied with wrong positions from parent class
         check(tree.mods)
-        check(tree.vparamss)
+        check(tree.trailingParamss)
       case tree: DefDef if tree.mods.is(ExtensionMethod) =>
-        tree.vparamss match {
+        tree.paramss match
           case vparams1 :: vparams2 :: rest if tree.name.isRightAssocOperatorName =>
-            check(tree.tparams)
-            check(vparams2)
-            check(vparams1)
-            check(rest)
+            // omit check for right-associatiove extension methods; their parameters were swapped
           case _ =>
-            check(tree.tparams)
-            check(tree.vparamss)
-        }
+            check(tree.paramss)
         check(tree.tpt)
         check(tree.rhs)
       case _ =>

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

@@ -22,7 +22,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   def unsplice(tree: Trees.Tree[T]): Trees.Tree[T] = tree
 
   def isDeclarationOrTypeDef(tree: Tree): Boolean = unsplice(tree) match {
-    case DefDef(_, _, _, _, EmptyTree)
+    case DefDef(_, _, _, EmptyTree)
       | ValDef(_, _, EmptyTree)
       | TypeDef(_, _) => true
     case _ => false
@@ -171,12 +171,6 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case nil => EmptyTree
   }
 
-  /** The arguments to the first constructor in `stats`. */
-  def firstConstructorArgs(stats: List[Tree]): List[Tree] = firstConstructor(stats) match {
-    case DefDef(_, _, args :: _, _, _) => args
-    case _                                => Nil
-  }
-
   /** Is tpt a vararg type of the form T* or => T*? */
   def isRepeatedParamType(tpt: Tree)(using Context): Boolean = tpt match {
     case ByNameTypeTree(tpt1) => isRepeatedParamType(tpt1)
@@ -198,7 +192,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
 
   /** All type and value parameter symbols of this DefDef */
   def allParamSyms(ddef: DefDef)(using Context): List[Symbol] =
-    (ddef.tparams ::: ddef.vparamss.flatten).map(_.symbol)
+    ddef.paramss.flatten.map(_.symbol)
 
   /** Does this argument list end with an argument of the form <expr> : _* ? */
   def isWildcardStarArgList(trees: List[Tree])(using Context): Boolean =
@@ -246,13 +240,17 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   def isGuardedCase(cdef: CaseDef): Boolean = cdef.guard ne EmptyTree
 
   /** Is this parameter list a using clause? */
-  def isUsingClause(vparams: List[ValDef])(using Context): Boolean = vparams match
-    case vparam :: _ =>
+  def isUsingClause(params: ParamClause)(using Context): Boolean = params match
+    case ValDefs(vparam :: _) =>
       val sym = vparam.symbol
       if sym.exists then sym.is(Given) else vparam.mods.is(Given)
     case _ =>
       false
 
+  def isUsingOrTypeParamClause(params: ParamClause)(using Context): Boolean = params match
+    case TypeDefs(_) => true
+    case _ => isUsingClause(params)
+
   /** The underlying pattern ignoring any bindings */
   def unbind(x: Tree): Tree = unsplice(x) match {
     case Bind(_, y) => unbind(y)
@@ -313,11 +311,11 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Given)
     case Closure(_, meth, _) => true
     case Block(Nil, expr) => isContextualClosure(expr)
-    case Block(DefDef(nme.ANON_FUN, _, params :: _, _, _) :: Nil, cl: Closure) =>
-      params match {
-        case param :: _ => param.mods.is(Given)
-        case Nil => cl.tpt.eq(untpd.ContextualEmptyTree) || defn.isContextFunctionType(cl.tpt.typeOpt)
-      }
+    case Block(DefDef(nme.ANON_FUN, params :: _, _, _) :: Nil, cl: Closure) =>
+      if params.isEmpty then
+        cl.tpt.eq(untpd.ContextualEmptyTree) || defn.isContextFunctionType(cl.tpt.typeOpt)
+      else
+        isUsingClause(params)
     case _ => false
   }
 
@@ -328,11 +326,17 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     case EmptyTree | _: Import => NoInitsInterface
     case tree: TypeDef => if (tree.isClassDef) NoInits else NoInitsInterface
     case tree: DefDef =>
-      if (tree.unforcedRhs == EmptyTree &&
-          tree.vparamss.forall(_.forall(_.rhs.isEmpty))) NoInitsInterface
-      else if (tree.mods.is(Given) && tree.tparams.isEmpty && tree.vparamss.isEmpty)
+      if tree.unforcedRhs == EmptyTree
+         && tree.paramss.forall {
+              case ValDefs(vparams) => vparams.forall(_.rhs.isEmpty)
+              case _ => true
+            }
+      then
+        NoInitsInterface
+      else if tree.mods.is(Given) && tree.paramss.isEmpty then
         EmptyFlags // might become a lazy val: TODO: check whether we need to suppress NoInits once we have new lazy val impl
-      else NoInits
+      else
+        NoInits
     case tree: ValDef => if (tree.unforcedRhs == EmptyTree) NoInitsInterface else EmptyFlags
     case _ => EmptyFlags
   }
@@ -354,8 +358,6 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
       case _ => None
     }
   }
-
-  // todo: fill with other methods from TreeInfo that only apply to untpd.Tree's
 }
 
 trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
@@ -371,7 +373,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case EmptyTree
        | TypeDef(_, _)
        | Import(_, _)
-       | DefDef(_, _, _, _, _) =>
+       | DefDef(_, _, _, _) =>
       Pure
     case vdef @ ValDef(_, _, _) =>
       if (vdef.symbol.flags is Mutable) Impure else exprPurity(vdef.rhs) `min` Pure

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

@@ -94,10 +94,9 @@ class TreeMapWithImplicits extends tpd.TreeMap {
         inContext(localCtx) {
           cpy.DefDef(tree)(
             tree.name,
-            transformSub(tree.tparams),
-            tree.vparamss mapConserve (transformSub(_)),
+            transformParamss(tree.paramss),
             transform(tree.tpt),
-            transform(tree.rhs)(using nestedScopeCtx(tree.vparamss.flatten)))
+            transform(tree.rhs)(using nestedScopeCtx(tree.paramss.flatten)))
         }
       case EmptyValDef =>
         tree

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

@@ -90,11 +90,10 @@ class TreeTypeMap(
       tree1.withType(mapType(tree1.tpe)) match {
         case id: Ident if tpd.needsSelect(id.tpe) =>
           ref(id.tpe.asInstanceOf[TermRef]).withSpan(id.span)
-        case ddef @ DefDef(name, tparams, vparamss, tpt, _) =>
-          val (tmap1, tparams1) = transformDefs(tparams)
-          val (tmap2, vparamss1) = tmap1.transformVParamss(vparamss)
-          val res = cpy.DefDef(ddef)(name, tparams1, vparamss1, tmap2.transform(tpt), tmap2.transform(ddef.rhs))
-          res.symbol.setParamssFromDefs(tparams1, vparamss1)
+        case ddef @ DefDef(name, paramss, tpt, _) =>
+          val (tmap1, paramss1) = transformAllParamss(paramss)
+          val res = cpy.DefDef(ddef)(name, paramss1, tmap1.transform(tpt), tmap1.transform(ddef.rhs))
+          res.symbol.setParamssFromDefs(paramss1)
           res.symbol.transformAnnotations {
             case ann: BodyAnnotation => ann.derivedAnnotation(transform(ann.tree))
             case ann => ann
@@ -139,14 +138,15 @@ class TreeTypeMap(
     (tmap, tmap.transformSub(trees))
   }
 
-  private def transformVParamss(vparamss: List[List[ValDef]]): (TreeTypeMap, List[List[ValDef]]) = vparamss match {
-    case vparams :: rest =>
-      val (tmap1, vparams1) = transformDefs(vparams)
-      val (tmap2, vparamss2) = tmap1.transformVParamss(rest)
-      (tmap2, vparams1 :: vparamss2)
+  private def transformAllParamss(paramss: List[ParamClause]): (TreeTypeMap, List[ParamClause]) = paramss match
+    case params :: paramss1 =>
+      val (tmap1, params1: ParamClause) = (params: @unchecked) match
+        case ValDefs(vparams) => transformDefs(vparams)
+        case TypeDefs(tparams) => transformDefs(tparams)
+      val (tmap2, paramss2) = tmap1.transformAllParamss(paramss1)
+      (tmap2, params1 :: paramss2)
     case nil =>
-      (this, vparamss)
-  }
+      (this, paramss)
 
   def apply[ThisTree <: tpd.Tree](tree: ThisTree): ThisTree = transform(tree).asInstanceOf[ThisTree]