def blockStats()

in rsc/src/main/scala/rsc/parse/scala/Terms.scala [447:523]
77 lines of code
21 McCabe index (conditional complexity)

  def blockStats(): List[Stat] = banEscapingWildcards {
    val stats = List.newBuilder[Stat]
    var exitOnError = false
    while (!in.token.isStatSeqEnd && in.token != CASE && !exitOnError) {
      if (in.token == IMPORT) {
        stats += `import`()
      } else if (in.token.isTermIntro) {
        stats += term(InBlock)
      } else if (in.token.isLocalDefnIntro) {
        val isImplicitLambda = {
          if (in.token == IMPLICIT) {
            val snapshot = in.snapshot()
            in.nextToken()
            val result = in.token == ID
            in.restore(snapshot)
            result
          } else {
            false
          }
        }
        if (isImplicitLambda) {
          stats += implicitLambda(InBlock)
        } else {
          val start = in.offset
          val mods = defnMods(modTokens.localDefn)
          val stat = in.token match {
            case CASECLASS =>
              val modCase = atPos(in.offset)(ModCase())
              val modClass = atPos(in.offset)(ModClass())
              in.nextToken()
              defnClass(mods :+ modCase :+ modClass)
            case CASEOBJECT =>
              val modCase = atPos(in.offset)(ModCase())
              in.nextToken()
              defnObject(mods :+ modCase)
            case CLASS =>
              val modClass = atPos(in.offset)(ModClass())
              in.nextToken()
              defnClass(mods :+ modClass)
            case DEF =>
              in.nextToken()
              defnDef(mods)
            case OBJECT =>
              in.nextToken()
              defnObject(mods)
            case TRAIT =>
              val modTrait = atPos(in.offset)(ModTrait())
              in.nextToken()
              defnClass(mods :+ modTrait)
            case TYPE =>
              in.nextToken()
              defnType(mods)
            case VAL =>
              val modVal = atPos(in.offset)(ModVal())
              in.nextToken()
              defnVal(mods :+ modVal)
            case VAR =>
              val modVar = atPos(in.offset)(ModVar())
              in.nextToken()
              defnVar(mods :+ modVar)
            case _ =>
              val errOffset = in.offset
              reportOffset(errOffset, ExpectedStartOfDefinition)
              atPos(errOffset)(errorStat())
          }
          stats += stat
        }
      } else if (!in.token.isStatSep && in.token != CASE) {
        exitOnError = in.token.mustStartStat
        val errOffset = in.offset
        reportOffset(errOffset, IllegalStartOfStatement)
        stats += atPos(errOffset)(errorTerm())
      }
      acceptStatSepUnlessAtEnd(CASE)
    }
    stats.result
  }