private def assignSym()

in rsc/src/main/scala/rsc/outline/Scheduler.scala [52:182]
128 lines of code
36 McCabe index (conditional complexity)

  private def assignSym(env: Env, outline: Outline): Unit = {
    val scope = {
      outline match {
        case DefnPackage(_, TermSelect(qual: TermPath, _), _) =>
          val parentPackage = DefnPackage(Mods(Nil), qual, Nil).withPos(outline.pos)
          apply(env, parentPackage)
          symtab.scopes(qual.id.sym)
        case DefnPackageObject(_, id, _, _, _, _) =>
          val parentPackage = DefnPackage(Mods(Nil), id, Nil).withPos(outline.pos)
          apply(env, parentPackage)
          symtab.scopes(id.sym)
        case _ =>
          env.owner
      }
    }
    outline match {
      case outline: DefnField =>
        outline.lang match {
          case ScalaLanguage | UnknownLanguage =>
            // FIXME: https://github.com/twitter/rsc/issues/93
            val getter = DefnMethod(
              outline.mods.dupe,
              TermId(outline.id.value).withPos(outline.id.pos),
              Nil,
              Nil,
              outline.tpt.map(_.dupe),
              outline.rhs.map(_.dupe)).withPos(outline.pos)
            apply(env, getter)
            if (outline.hasVar) {
              val param =
                Param(Mods(Nil), TermId("x$1"), outline.tpt.map(_.dupe), None).withPos(outline.pos)
              val setter = DefnMethod(
                // FIXME: https://github.com/twitter/rsc/issues/93
                outline.mods.filter(!_.isInstanceOf[ModImplicit]),
                TermId(outline.id.value + "_=").withPos(outline.id.pos),
                Nil,
                List(List(param)),
                Some(TptId("Unit").withSym(UnitClass)),
                outline.rhs.map(_.dupe)
              ).withPos(outline.pos)
              apply(env, setter)
            }
            if (outline.hasBean) {
              // FIXME: https://github.com/twitter/rsc/issues/293
              val beanGetter = DefnMethod(
                outline.mods.filter(!_.isInstanceOf[ModVal]),
                TermId("get" + outline.id.value.capitalize).withPos(outline.id.pos),
                Nil,
                List(List()),
                outline.tpt.map(_.dupe),
                outline.rhs.map(_.dupe)
              ).withPos(outline.pos)
              apply(env, beanGetter)
            }
          case JavaLanguage =>
            val sym = TermSymbol(scope.sym, outline.id.value)
            scope.enter(outline.id.name, sym)
            outline.id.sym = sym
            symtab.outlines.put(sym, outline)
            symtab.envs.put(sym, env)
        }
      case outline =>
        val sym = {
          if (scope.sym.isGlobal) {
            outline match {
              case outline: DefnClass =>
                TypeSymbol(scope.sym, outline.id.value)
              case outline: DefnConstant =>
                TermSymbol(scope.sym, outline.id.value)
              case outline: DefnDef =>
                if (outline.hasVal) {
                  TermSymbol(scope.sym, outline.id.value)
                } else {
                  def loop(attempt: Int): String = {
                    val disambig = if (attempt == 0) s"()" else s"(+$attempt)"
                    val sym = MethodSymbol(scope.sym, outline.id.value, disambig)
                    if (symtab.outlines.contains(sym)) loop(attempt + 1)
                    else sym
                  }
                  loop(0)
                }
              case outline: DefnField =>
                crash(outline)
              case outline: DefnObject =>
                TermSymbol(scope.sym, outline.id.value)
              case outline: DefnPackage =>
                PackageSymbol(scope.sym, outline.id.value)
              case outline: DefnPackageObject =>
                TermSymbol(scope.sym, "package")
              case outline: DefnType =>
                TypeSymbol(scope.sym, outline.id.value)
              case outline: Param =>
                val gensym = gensyms(outline)
                outline.id match {
                  case AnonId() => ParamSymbol(scope.sym, gensym.anon())
                  case id: NamedId => ParamSymbol(scope.sym, id.value)
                }
              case outline: PatVar =>
                val gensym = gensyms(outline)
                outline.id match {
                  case AnonId() => TermSymbol(scope.sym, gensym.anon())
                  case id: NamedId => TermSymbol(scope.sym, id.value)
                }
              case outline: Self =>
                SelfSymbol(scope.sym)
              case outline: TypeParam =>
                val gensym = gensyms(outline)
                outline.id match {
                  case AnonId() => TypeParamSymbol(scope.sym, gensym.anon())
                  case id: NamedId => TypeParamSymbol(scope.sym, id.value)
                }
            }
          } else {
            val gensym = gensyms.global
            LocalSymbol(gensym)
          }
        }
        outline.id match {
          case id: NamedId =>
            outline match {
              case _: DefnPackageObject => scope.enter(TermName("package"), sym)
              case _ => scope.enter(id.name, sym)
            }
          case id: AnonId =>
            ()
        }
        outline.id.sym = sym
        symtab.outlines.put(sym, outline)
        symtab.envs.put(sym, env)
    }
  }