private def emitSig()

in rsc/src/main/scala/rsc/scalasig/Pickle.scala [173:252]
80 lines of code
20 McCabe index (conditional complexity)

  private def emitSig(ssig: Sig): Ref = {
    ssig match {
      case ssig: NonvalueSig =>
        entries.getOrElseUpdate(SigKey(ssig)) {
          ssig match {
            case NoSig =>
              NoType
            case PolySig(stparamSyms, ssig) =>
              val ret = emitSig(ssig)
              val tparams = emitScope(stparamSyms)
              PolyType(ret, tparams)
            case ClassSig(sparents, ssym) =>
              val sym = emitSym(ssym, RefMode)
              val parents = {
                if (ssym.isJavaAnnotation) {
                  val sparents = List.newBuilder[s.Type]
                  sparents += s.TypeRef(s.NoType, ScalaAnnotationClass, Nil)
                  sparents += s.TypeRef(s.NoType, ScalaClassfileAnnotationClass, Nil)
                  sparents += s.TypeRef(s.NoType, JavaAnnotationClass, Nil)
                  sparents.result.map(emitTpe)
                } else {
                  sparents.map(emitTpe)
                }
              }
              if (ssym.isObject || ssym.isPackageObject) {
                val smoduleCtor = Transients.sdefaultCtor(ssym)
                mtab(smoduleCtor.symbol) = smoduleCtor
                emitEmbeddedSym(smoduleCtor.symbol, RefMode)
              }
              if (ssym.isTrait && !ssym.isInterface) {
                val straitCtor = Transients.straitCtor(ssym)
                mtab(straitCtor.symbol) = straitCtor
                emitEmbeddedSym(straitCtor.symbol, RefMode)
              }
              emitScope(ssym.sdecls)
              if (ssym.isValueClass) {
                if (!mtab.contains(ssym.companionSym)) {
                  val scompanion = Transients.ssyntheticCompanion(ssym)
                  mtab(scompanion.symbol) = scompanion
                  emitEmbeddedSym(scompanion.symbol, ModuleRefMode)
                  emitEmbeddedSym(scompanion.symbol, RefMode)
                }
              }
              if (ssym.isValueCompanion) {
                val sinfos = Transients.sextensionMethods(ssym)
                sinfos.foreach(sinfo => mtab(sinfo.symbol) = sinfo)
                sinfos.foreach(sinfo => emitEmbeddedSym(sinfo.symbol, RefMode))
              }
              if (ssym.isJavaAnnotation) {
                val sannCtor = Transients.sdefaultCtor(ssym)
                mtab(sannCtor.symbol) = sannCtor
                emitEmbeddedSym(sannCtor.symbol, RefMode)
              }
              ClassInfoType(sym, parents)
            case RefinedSig(sparents, ssym) =>
              val sym = emitSym(ssym, RefMode)
              val parents = sparents.map(emitTpe)
              emitScope(ssym.sdecls)
              RefinedType(sym, parents)
            case NullaryMethodSig(stpe) =>
              val ret = emitTpe(stpe)
              PolyType(ret, Nil)
            case MethodSig(sparams, stpe) =>
              val ret = emitTpe(stpe)
              val params = emitScope(sparams)
              MethodType(ret, params)
            case NaryMethodSig(sparams, ssig) =>
              val ret = emitSig(ssig)
              val params = emitScope(sparams)
              MethodType(ret, params)
            case TypeSig(slo, shi) =>
              val lo = emitTpe(slo)
              val hi = emitTpe(shi)
              TypeBounds(lo, hi)
          }
        }
      case ValueSig(stpe) =>
        emitTpe(stpe)
    }
  }