private def emitTpe()

in rsc/src/main/scala/rsc/scalasig/Pickle.scala [254:328]
74 lines of code
21 McCabe index (conditional complexity)

  private def emitTpe(stpe: s.Type): Ref = {
    entries.getOrElseUpdate(TypeKey(stpe)) {
      stpe match {
        case s.NoType =>
          NoType
        case s.TypeRef(spre, ssym, stargs) =>
          val pre = spre match {
            case s.NoType => emitPre(ssym.spre)
            case stpe => emitPre(SomePre(stpe))
          }
          val sym = emitSym(ssym, RefMode)
          val targs = stargs.map(emitTpe).toList
          TypeRef(pre, sym, targs)
        case s.SingleType(spre, ssym) =>
          val pre = spre match {
            case s.NoType => emitPre(ssym.spre)
            case stpe => emitPre(SomePre(stpe))
          }
          val sym = emitSym(ssym, ModuleRefMode)
          SingleType(pre, sym)
        case s.ThisType(ssym) =>
          val sym = emitSym(ssym, RefMode)
          ThisType(sym)
        case s.SuperType(spre, ssym) =>
          // FIXME: https://github.com/twitter/rsc/issues/96
          crash(stpe)
        case s.ConstantType(sconst) =>
          val lit = emitLiteral(sconst.value.get)
          ConstantType(lit)
        case stpe @ s.StructuralType(sret, sdecls) =>
          stack.inStructuralType(stpe) { srefinement =>
            val sym = emitEmbeddedSym(srefinement, RefMode)
            val parents = {
              sret match {
                case s.NoType => List(emitTpe(s.TypeRef(s.NoType, AnyRefClass, Nil)))
                case s.WithType(sparents) => sparents.toList.map(emitTpe)
                case sparent => List(emitTpe(sparent))
              }
            }
            RefinedType(sym, parents)
          }
        case s.AnnotatedType(sannots, sret) =>
          val ret = emitTpe(sret)
          val annots = sannots.toList.map(emitAnnotInfo)
          AnnotatedType(ret, annots)
        case stpe @ s.ExistentialType(sret, sdecls) =>
          stack.inExistentialType(stpe) {
            val decls = emitScope(sdecls)
            val ret = emitTpe(sret)
            ExistentialType(ret, decls)
          }
        case s.ByNameType(sret) =>
          val pre = emitPre(ByNameClass.spre)
          val sym = emitSym(ByNameClass, RefMode)
          val targs = List(emitTpe(sret))
          TypeRef(pre, sym, targs)
        case s.RepeatedType(sret) =>
          val pre = emitPre(RepeatedClass.spre)
          val sym = emitSym(RepeatedClass, RefMode)
          val targs = List(emitTpe(sret))
          TypeRef(pre, sym, targs)
        case stpe @ s.UniversalType(stparams, sret) =>
          stparams.infos.foreach(sinfo => mtab(sinfo.symbol) = sinfo)
          val slambdaRefinement = Transients.slambdaRefinement(stpe)
          val List(slambda) = slambdaRefinement.declarations.infos
          mtab(slambda.symbol) = slambda
          emitTpe(slambdaRefinement)
          val tparams = emitScope(stparams)
          val ret = emitTpe(sret)
          PolyType(ret, tparams)
        case _ =>
          crash(stpe)
      }
    }
  }