Make accessing parameter symbols more convenient

Add a method `paramSymss` that mirrors the type structure of a method.
Rename the old `paramss` to `rawParamss` to caution against naive uses.

Author: odersky

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

@@ -227,21 +227,21 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   /** A DefDef with given method symbol `sym`.
    *  @rhsFn  A function from type parameter types and term parameter references
    *          to the method's right-hand side.
-   *  Parameter symbols are taken from the `paramss` field of `sym`, or
-   *  are freshly generated if `paramss` is empty.
+   *  Parameter symbols are taken from the `rawParamss` field of `sym`, or
+   *  are freshly generated if `rawParamss` is empty.
    */
   def polyDefDef(sym: TermSymbol, rhsFn: List[Type] => List[List[Tree]] => Tree)(implicit ctx: Context): DefDef = {
 
     val (tparams, existingParamss, mtp) = sym.info match {
       case tp: PolyType =>
-        val (tparams, existingParamss) = sym.paramss match
+        val (tparams, existingParamss) = sym.rawParamss match
           case tparams :: vparamss =>
             assert(tparams.hasSameLengthAs(tp.paramNames) && tparams.head.isType)
             (tparams.asInstanceOf[List[TypeSymbol]], vparamss)
           case _ =>
             (ctx.newTypeParams(sym, tp.paramNames, EmptyFlags, tp.instantiateParamInfos(_)), Nil)
         (tparams, existingParamss, tp.instantiate(tparams map (_.typeRef)))
-      case tp => (Nil, sym.paramss, tp)
+      case tp => (Nil, sym.rawParamss, tp)
     }
 
     def valueParamss(tp: Type, existingParamss: List[List[Symbol]]): (List[List[TermSymbol]], Type) = tp match {

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

@@ -576,6 +576,7 @@ object Flags {
   val SyntheticGivenMethod: FlagSet          = Synthetic | Given | Method
   val SyntheticModule: FlagSet               = Synthetic | Module
   val SyntheticOpaque: FlagSet               = Synthetic | Opaque
+  val SyntheticParam: FlagSet                = Synthetic | Param
   val SyntheticTermParam: FlagSet            = Synthetic | TermParam
   val SyntheticTypeParam: FlagSet            = Synthetic | TypeParam
 }

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

@@ -376,17 +376,55 @@ object SymDenotations {
     /** If this is a method, the parameter symbols, by section.
      *  Both type and value parameters are included. Empty sections are skipped.
      */
-    final def paramss: List[List[Symbol]] = myParamss
-    final def paramss_=(pss: List[List[Symbol]]): Unit =
+    final def rawParamss: List[List[Symbol]] = myParamss
+    final def rawParamss_=(pss: List[List[Symbol]]): Unit =
       myParamss = pss
 
     final def setParamss(tparams: List[Symbol], vparamss: List[List[Symbol]])(using Context): Unit =
-      paramss = (if tparams.isEmpty then vparamss else tparams :: vparamss)
+      rawParamss = (if tparams.isEmpty then vparamss else tparams :: vparamss)
         .filterConserve(!_.isEmpty)
 
     final def setParamssFromDefs(tparams: List[TypeDef[?]], vparamss: List[List[ValDef[?]]])(using Context): Unit =
       setParamss(tparams.map(_.symbol), vparamss.map(_.map(_.symbol)))
 
+    /** A pair consistsing of type paremeter symbols and value parameter symbol lists
+     *  of this method definition, or (Nil, Nil) for other symbols.
+     *  Makes use of `rawParamss` when present, or constructs fresh parameter symbols otherwise.
+     *  This method can be allocation-heavy.
+     */
+    final def paramSymss(using ctx: Context): (List[TypeSymbol], List[List[TermSymbol]]) =
+
+      def recurWithParamss(info: Type, paramss: List[List[Symbol]]): List[List[Symbol]] =
+        info match
+          case info: LambdaType =>
+            if info.paramNames.isEmpty then Nil :: recurWithParamss(info.resType, paramss)
+            else paramss.head :: recurWithParamss(info.resType, paramss.tail)
+          case _ =>
+            Nil
+
+      def recurWithoutParamss(info: Type): List[List[Symbol]] = info match
+        case info: LambdaType =>
+          val params = info.paramNames.lazyZip(info.paramInfos).map((pname, ptype) =>
+            ctx.newSymbol(symbol, pname, SyntheticParam, ptype))
+          val prefs = params.map(_.namedType)
+          for param <- params do
+            param.info = param.info.substParams(info, prefs)
+          params :: recurWithoutParamss(info.instantiate(prefs))
+        case _ =>
+          Nil
+
+      try
+        val allParamss =
+          if rawParamss.isEmpty then recurWithoutParamss(info)
+          else recurWithParamss(info, rawParamss)
+        info match
+          case info: PolyType => (allParamss.head, allParamss.tail).asInstanceOf
+          case _ => (Nil, allParamss).asInstanceOf
+      catch case NonFatal(ex) =>
+        println(i"paramSymss failure for $symbol, $info, $rawParamss")
+        throw ex
+    end paramSymss
+
     /** The denotation is completed: info is not a lazy type and attributes have defined values */
     final def isCompleted: Boolean = !myInfo.isInstanceOf[LazyType]
 
@@ -1466,7 +1504,7 @@ object SymDenotations {
       info: Type = null,
       privateWithin: Symbol = null,
       annotations: List[Annotation] = null,
-      paramss: List[List[Symbol]] = null)(
+      rawParamss: List[List[Symbol]] = null)(
         using ctx: Context): SymDenotation = {
       // simulate default parameters, while also passing implicit context ctx to the default values
       val initFlags1 = (if (initFlags != UndefinedFlags) initFlags else this.flags)
@@ -1475,10 +1513,10 @@ object SymDenotations {
         assert(ctx.phase.changesParents, i"undeclared parent change at ${ctx.phase} for $this, was: $info, now: $info1")
       val privateWithin1 = if (privateWithin != null) privateWithin else this.privateWithin
       val annotations1 = if (annotations != null) annotations else this.annotations
-      val paramss1 = if paramss != null then paramss else this.paramss
+      val rawParamss1 = if rawParamss != null then rawParamss else this.rawParamss
       val d = ctx.SymDenotation(symbol, owner, name, initFlags1, info1, privateWithin1)
       d.annotations = annotations1
-      d.paramss = paramss1
+      d.rawParamss = rawParamss1
       d.registeredCompanion = registeredCompanion
       d
     }

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -176,7 +176,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
   /** A map from symbols to their associated `decls` scopes */
   private val symScopes = mutable.AnyRefMap[Symbol, Scope]()
 
-  /** A dummy buffer to pass to `readType` when no `paramss` are collected */
+  /** A dummy buffer to pass to `readType` when no `rawParamss` are collected */
   private val throwAwayBuffer = new ListBuffer[List[Symbol]]
 
   protected def errorBadSignature(msg: String, original: Option[RuntimeException] = None)(implicit ctx: Context): Nothing = {
@@ -581,7 +581,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
           if denot.is(Method) then new ListBuffer[List[Symbol]]
           else throwAwayBuffer
         val tp = at(inforef, () => readType(paramssBuf)(ctx))
-        if denot.is(Method) then denot.paramss = paramssBuf.toList
+        if denot.is(Method) then denot.rawParamss = paramssBuf.toList
 
         denot match {
           case denot: ClassDenotation if !isRefinementClass(denot.symbol) =>

compiler/src/dotty/tools/dotc/reporting/Message.scala

@@ -89,7 +89,7 @@ abstract class Message(val errorId: ErrorMessageID) { self =>
    *  they look weird and are normally follow-up errors to something that was
    *  diagnosed before.
    */
-   def isNonSensical: Boolean = { message; myIsNonSensical }
+  def isNonSensical: Boolean = { message; myIsNonSensical }
 
   /** The implicit `Context` in messages is a large thing that we don't want
     * persisted. This method gets around that by duplicating the message,

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

@@ -426,10 +426,10 @@ class TreeChecker extends Phase with SymTransformer {
         (ddef.tparams :: ddef.vparamss).filter(!_.isEmpty).map(_.map(_.symbol))
       def layout(symss: List[List[Symbol]]): String =
         symss.map(syms => i"($syms%, %)").mkString
-      assert(ctx.erasedTypes || sym.paramss == defParamss,
+      assert(ctx.erasedTypes || sym.rawParamss == defParamss,
         i"""param mismatch for ${sym.showLocated}:
            |defined in tree  = ${layout(defParamss)}
-           |stored in symbol = ${layout(sym.paramss)}""")
+           |stored in symbol = ${layout(sym.rawParamss)}""")
       withDefinedSyms(ddef.tparams) {
         withDefinedSyms(ddef.vparamss.flatten) {
           if (!sym.isClassConstructor && !(sym.name eq nme.STATIC_CONSTRUCTOR))