private implicit def importFromRu()

in scala-repl/src/main/scala/org/jetbrains/ztools/scala/interpreter/ZtoolsInterpreterWrapper.scala [32:85]
46 lines of code
10 McCabe index (conditional complexity)

  private implicit def importFromRu(sym: ru.Symbol) = importToGlobal importSymbol sym

  private implicit def importToRu(sym: Symbol): ru.Symbol = importToRuntime importSymbol sym

  // see https://github.com/scala/scala/pull/5852/commits/a9424205121f450dea2fe2aa281dd400a579a2b7
  def valueOfTerm(id: String): Option[Any] = exitingTyper {
    def fixClassBasedFullName(fullName: List[String]): List[String] = {
      if (settings.Yreplclassbased.value) {
        val line :: read :: rest = fullName
        line :: read :: "INSTANCE" :: rest
      } else fullName
    }

    def value(fullName: String) = {
      val universe = iMain.runtimeMirror.universe
      import universe.{InstanceMirror, Symbol, TermName}
      val pkg :: rest = fixClassBasedFullName((fullName split '.').toList)
      val top = iMain.runtimeMirror.staticPackage(pkg)

      @annotation.tailrec
      def loop(inst: InstanceMirror, cur: Symbol, path: List[String]): Option[Any] = {
        def mirrored =
          if (inst != null) inst
          else iMain.runtimeMirror reflect (iMain.runtimeMirror reflectModule cur.asModule).instance

        path match {
          case last :: Nil =>
            cur.typeSignature.decls find (x => x.name.toString == last && x.isAccessor) map { m =>
              (mirrored reflectMethod m.asMethod).apply()
            }
          case next :: rest =>
            val s = cur.typeSignature.member(TermName(next))
            val i =
              if (s.isModule) {
                if (inst == null) null
                else iMain.runtimeMirror reflect (inst reflectModule s.asModule).instance
              }
              else if (s.isAccessor) {
                iMain.runtimeMirror reflect (mirrored reflectMethod s.asMethod).apply()
              }
              else {
                assert(false, s.fullName)
                inst
              }
            loop(i, s, rest)
          case Nil => None
        }
      }

      loop(null, top, rest)
    }

    Option(iMain.symbolOfTerm(id)) filter (_.exists) flatMap (s => Trying(value(s.fullName)).toOption.flatten)
  }