private def templateBraces()

in rsc/src/main/scala/rsc/parse/scala/Templates.scala [88:193]
106 lines of code
24 McCabe index (conditional complexity)

  private def templateBraces(earlies: List[Stat], inits: List[Init]): Template = {
    banEscapingWildcards {
      newLineOptWhenFollowedBy(LBRACE)
      if (in.token == LBRACE) {
        inBraces {
          var self: Option[Self] = None
          val stats = List.newBuilder[Stat]
          if (in.token.isTermIntro) {
            val snapshot = in.snapshot()
            val firstStat = term1(InTemplate)
            if (in.token == ARROW) {
              in.restore(snapshot)
              val start = in.offset
              val id = {
                if (in.token == ID) {
                  termId()
                } else if (in.token == THIS || in.token == USCORE) {
                  in.nextToken()
                  atPos(start)(anonId())
                } else {
                  val errOffset = in.offset
                  reportOffset(errOffset, IllegalSelf)
                  in.nextToken()
                  atPos(errOffset)(TermId(gensym.error()))
                }
              }
              val tpt = {
                if (in.token == COLON) {
                  in.nextToken()
                  Some(infixTpt())
                } else {
                  None
                }
              }
              accept(ARROW)
              self = Some(atPos(start)(Self(id, tpt)))
            } else {
              stats += firstStat
              acceptStatSepUnlessAtEnd()
            }
          }
          var exitOnError = false
          while (!in.token.isStatSeqEnd && !exitOnError) {
            if (in.token == IMPORT) {
              stats += `import`()
            } else if (in.token.isTermIntro) {
              stats += term1(InTemplate)
            } else if (in.token.isTemplateDefnIntro) {
              val start = in.offset
              val mods = defnMods(modTokens.templateDefn)
              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) {
              exitOnError = in.token.mustStartStat
              reportOffset(in.offset, IllegalStartOfDefinition)
            }
            acceptStatSepUnlessAtEnd()
          }
          Template(earlies, inits, self, Some(stats.result))
        }
      } else {
        val self = None
        val stats = None
        Template(earlies, inits, self, stats)
      }
    }
  }