def paramss()

in rsc/src/main/scala/rsc/outline/Synthesizer.scala [243:320]
78 lines of code
19 McCabe index (conditional complexity)

  def paramss(env: Env, tree: Parameterized): Unit = {
    if (symtab.desugars.paramss.contains(tree)) {
      ()
    } else {
      val paramssBuf = List.newBuilder[List[Param]]
      val isCtor = tree.isInstanceOf[DefnCtor] || tree.isInstanceOf[PrimaryCtor]
      if (isCtor && (tree.paramss.isEmpty || tree.paramss.forall(_.isImplicit))) {
        paramssBuf += List()
      }
      val tparams = {
        tree match {
          case _: DefnCtor | _: PrimaryCtor =>
            val enclosingClass = env.scopes.collectFirst {
              case x: TemplateScope if x.tree.isInstanceOf[DefnClass] => x.tree
            }
            enclosingClass.map(_.tparams).getOrElse(Nil)
          case _ =>
            tree.tparams
        }
      }
      var pendingEvidences = tparams.exists(tp => tp.vbounds.nonEmpty || tp.cbounds.nonEmpty)
      if (pendingEvidences) {
        def evidenceParams: List[Param] = {
          val gensym = gensyms(tree)
          val paramsBuf = List.newBuilder[Param]
          tparams.foreach { tparam =>
            tparam.id match {
              case tparamId: TptId =>
                tparam.vbounds.foreach { vbound =>
                  val mods = Mods(List(ModImplicit()))
                  val id = TermId(gensym.evidence())
                  val tpt = {
                    val core = TptId("Function1").withSym(FunctionClass(1))
                    TptParameterize(core, List(tparamId, vbound))
                  }
                  val param = Param(mods, id, Some(tpt), None)
                  paramsBuf += param.withPos(vbound.pos)
                }
                tparam.cbounds.foreach { cbound =>
                  val mods = Mods(List(ModImplicit()))
                  val id = {
                    val result = TermId(gensym.evidence())
                    tree match {
                      case _: PrimaryCtor => result.withPos(cbound.pos)
                      case _ => result
                    }
                  }
                  val tpt = TptParameterize(cbound, List(tparamId))
                  val param = Param(mods, id, Some(tpt), None)
                  paramsBuf += param.withPos(cbound.pos)
                }
              case _ =>
                ()
            }
          }
          paramsBuf.result
        }
        tree.paramss.foreach { params =>
          val paramsBuf = List.newBuilder[Param]
          params.foreach { param =>
            if (param.hasImplicit && pendingEvidences) {
              evidenceParams.foreach(paramsBuf.+=)
              pendingEvidences = false
            }
            paramsBuf += param
          }
          paramssBuf += paramsBuf.result
        }
        if (pendingEvidences) {
          paramssBuf += evidenceParams
          pendingEvidences = false
        }
      } else {
        paramssBuf ++= tree.paramss
      }
      symtab.desugars.paramss.put(tree, paramssBuf.result)
    }
  }