private def sketch()

in rsc/src/main/scala/rsc/outline/Scheduler.scala [547:608]
62 lines of code
22 McCabe index (conditional complexity)

  private def sketch(env: Env, tree: Sketchy): Unit = {
    def loop(tpt: Tpt): Unit = {
      tpt match {
        case TptApply(fun, targs) =>
          loop(fun)
          targs.foreach(loop)
        case TptArray(tpt) =>
          loop(tpt)
        case TptAnnotate(tpt, mods) =>
          loop(tpt)
        case TptByName(tpt) =>
          loop(tpt)
        case existentialTpt @ TptExistential(tpt, stats) =>
          loop(tpt)
          if (!symtab.scopes.contains(existentialTpt)) {
            val existentialScope = ExistentialScope()
            symtab.scopes.put(existentialTpt, existentialScope)
            val existentialEnv = existentialScope :: env
            stats.foreach(apply(existentialEnv, _))
            existentialScope.succeed()
          }
        case TptIntersect(tpts) =>
          tpts.foreach(loop)
        case tpt: TptLit =>
          ()
        case tpt: TptPath =>
          tpt match {
            case TptProject(qual @ TptRefine(None, _), _) => loop(qual)
            case _ => ()
          }
        case tpt: TptPrimitive =>
          ()
        case refineTpt @ TptRefine(tpt, stats) =>
          tpt.foreach(loop)
          if (!symtab.scopes.contains(refineTpt)) {
            val refineScope = RefineScope()
            symtab.scopes.put(refineTpt, refineScope)
            val refineEnv = refineScope :: env
            stats.foreach(apply(refineEnv, _))
            refineScope.succeed()
          }
        case TptRepeat(tpt) =>
          loop(tpt)
        case TptWildcard(ubound, lbound) =>
          ubound.foreach(loop)
          lbound.foreach(loop)
        case TptWildcardExistential(_, tpt) =>
          loop(tpt)
        case TptWith(tpts) =>
          tpts.foreach(loop)
      }
    }
    if (!symtab.sketches.contains(tree)) {
      val sketch = Sketch(tree)
      symtab.sketches.put(tree, sketch)
      todo.add(env, sketch)
      tree match {
        case tree: Tpt => loop(tree)
        case tree: ModWithin => ()
      }
    }
  }