def sextensionMethods()

in rsc/src/main/scala/rsc/scalasig/Pickle.scala [1145:1241]
97 lines of code
6 McCabe index (conditional complexity)

    def sextensionMethods(sobjectSym: String): List[s.SymbolInformation] = {
      val xbuf = List.newBuilder[s.SymbolInformation]
      val sclassSym = sobjectSym.companionSym
      val s.ClassSignature(sctparamScope, _, _, Some(s.Scope(scdecls, _))) =
        mtab(sclassSym).signature
      val Some(s.Scope(sctparamSyms, _)) = sctparamScope
      val _ +: scmethodSyms = scdecls.dropWhile(_.desc.value != "<init>")
      scmethodSyms.foreach { smethodSym =>
        val smethod = mtab(smethodSym)
        val xmethodDisambig = {
          val smethodOverloads = scmethodSyms.filter(_.desc.value == smethodSym.desc.value)
          if (smethodOverloads.length == 1) ""
          else smethodOverloads.indexOf(smethodSym).toString
        }
        val xmethodName = smethodSym.desc.value + "$extension" + xmethodDisambig
        val xmethodDesc = d.Method(xmethodName, "()")
        val xmethodSym = Symbols.Global(sobjectSym, xmethodDesc)
        val xmethodSig = {
          val s.MethodSignature(stparamSyms, sparamSymss, sret) =
            mtab(smethodSym).signature
          val stparamMap = mutable.Map[String, String]()
          def rebind(stpe: s.Type): s.Type = {
            stpe match {
              case s.TypeRef(spre, ssym, sargs) =>
                val spre1 = rebind(spre)
                val ssym1 = stparamMap.getOrElse(ssym, ssym)
                val sargs1 = sargs.map(rebind)
                s.TypeRef(spre1, ssym1, sargs1)
              case s.ByNameType(stpe) =>
                val stpe1 = rebind(stpe)
                s.ByNameType(stpe1)
              case s.RepeatedType(stpe) =>
                val stpe1 = rebind(stpe)
                s.RepeatedType(stpe1)
              case stpe =>
                stpe
            }
          }
          val xtparamSyms = stparamSyms.map { stparamScope =>
            val s.Scope(stparamSyms, _) = stparamScope
            val sxtparamSyms = stparamSyms ++ sctparamSyms
            val xtparamSyms = sxtparamSyms.map { sxtparamSym =>
              val xtparamSym = Symbols.Global(xmethodSym, sxtparamSym.desc)
              val stparam = mtab(sxtparamSym)
              xbuf += stparam.copy(symbol = xtparamSym)
              stparamMap(sxtparamSym) = xtparamSym
              xtparamSym
            }
            s.Scope(xtparamSyms)
          }
          val xparamssBuf = List.newBuilder[s.Scope]
          val xthisName = "$this"
          val xthisSym = Symbols.Global(xmethodSym, d.Parameter(xthisName))
          val xthisSig = s.ValueSignature(rebind(sclassSym.stpe))
          val xthis = s.SymbolInformation(
            symbol = xthisSym,
            language = l.SCALA,
            kind = k.PARAMETER,
            properties = 0,
            displayName = xthisName,
            signature = xthisSig,
            annotations = Nil,
            access = s.NoAccess
          )
          xbuf += xthis
          xparamssBuf += s.Scope(List(xthisSym))
          sparamSymss.foreach { sparamScope =>
            val s.Scope(sparamSyms, _) = sparamScope
            val xparamsBuf = List.newBuilder[String]
            sparamSyms.foreach { sparamSym =>
              val xparamSym = Symbols.Global(xmethodSym, sparamSym.desc)
              val sparam = mtab(sparamSym)
              val s.ValueSignature(sparamTpe) = sparam.signature
              val xparamSig = s.ValueSignature(rebind(sparamTpe))
              xbuf += sparam.copy(symbol = xparamSym, signature = xparamSig)
              xparamsBuf += xparamSym
              xparamSym
            }
            xparamssBuf += s.Scope(xparamsBuf.result)
          }
          val xparamss = xparamssBuf.result
          val xret = rebind(sret)
          s.MethodSignature(xtparamSyms, xparamss, xret)
        }
        xbuf += s.SymbolInformation(
          symbol = xmethodSym,
          language = l.SCALA,
          kind = k.METHOD,
          properties = p.FINAL.value | smethod.properties,
          displayName = xmethodName,
          signature = xmethodSig,
          annotations = Nil,
          access = s.PublicAccess()
        )
      }
      xbuf.result
    }