private def defaultGetters()

in rsc/src/main/scala/rsc/outline/Synthesizer.scala [75:144]
70 lines of code
17 McCabe index (conditional complexity)

  private def defaultGetters(env: Env, treeTparams: List[TypeParam], tree: Parameterized): Unit = {
    var paramPos = 0
    val treeParamss = tree.paramss
    treeParamss.zipWithIndex.foreach {
      case (params, i) =>
        params.foreach { param =>
          paramPos += 1
          if (param.rhs.nonEmpty) {
            val mods = tree.mods.flatMap {
              case mod: ModPrivate =>
                Some(mod)
              case mod: ModPrivateThis =>
                Some(ModPrivate())
              case mod: ModPrivateWithin =>
                if (settings.abi == Abi211) None
                else Some(mod)
              case mod: ModProtected =>
                Some(mod)
              case mod: ModProtectedThis =>
                Some(ModProtected())
              case mod: ModProtectedWithin =>
                if (settings.abi == Abi211) Some(ModProtected())
                else Some(mod)
              case mod: ModFinal =>
                Some(mod)
              case _ =>
                None
            }
            val id = TermId(tree.id.valueopt.get + "$default$" + paramPos)
            val tparams = treeTparams.map { tp =>
              val mods = Mods(Nil)
              val id = TptId(tp.id.valueopt.get).withPos(tp.id.pos)
              val lbound = tp.lbound.map(_.dupe)
              val ubound = tp.ubound.map(_.dupe)
              val tparam = TypeParam(mods, id, Nil, lbound, ubound, Nil, Nil)
              tparam.withPos(tp.pos)
            }
            val paramss = treeParamss
              .take(i)
              .map(_.map { p =>
                val mods = Mods(Nil)
                val id = TermId(p.id.valueopt.get)
                val tpt = p.tpt.map(_.dupe)
                val param = Param(mods, id, tpt, None)
                param.withPos(p.pos)
              })
            val ret = {
              val paramTpt = param.tpt.map(_.dupe).map {
                case TptByName(tpt) => tpt
                case tpt => tpt
              }
              val rhsTpt = param.rhs match {
                case Some(TermAscribe(_, tpt)) => Some(tpt)
                case _ => None
              }
              val tpt = rhsTpt.orElse(paramTpt)
              tpt.map { tpt =>
                val annotSym = UncheckedVarianceClass
                val annotTpt = TptId("uncheckedVariance").withSym(annotSym)
                val annot = ModAnnotation(Init(annotTpt, Nil))
                TptAnnotate(tpt, Mods(List(annot)))
              }
            }
            val rhs = Some(TermStub())
            val meth = DefnMethod(mods, id, tparams, paramss, ret, rhs)
            scheduler(env, meth.withPos(param.pos))
          }
        }
    }
  }