def term1()

in rsc/src/main/scala/rsc/parse/scala/Terms.scala [50:187]
138 lines of code
32 McCabe index (conditional complexity)

  def term1(location: Location): Term = {
    val start = in.offset
    in.token match {
      case IF =>
        in.nextToken()
        val cond = inParens(term())
        newLinesOpt()
        val thenp = term()
        val elsep = {
          if (in.token == ELSE) {
            in.nextToken()
            Some(term())
          } else {
            None
          }
        }
        TermIf(cond, thenp, elsep)
      case WHILE =>
        in.nextToken()
        val cond = inParens(term())
        newLinesOpt()
        val body = term()
        TermWhile(cond, body)
      case DO =>
        in.nextToken()
        val body = term()
        if (in.token.isStatSep) in.nextToken()
        accept(WHILE)
        val cond = inParens(term())
        TermDo(body, cond)
      case TRY =>
        in.nextToken()
        val expr = term()
        val catchpOpt = {
          if (in.token == CATCH) {
            in.nextToken()
            Some(term())
          } else {
            None
          }
        }
        val finallyp = {
          if (in.token == FINALLY) {
            in.nextToken()
            Some(term())
          } else {
            None
          }
        }
        catchpOpt match {
          case Some(TermPartialFunction(cases)) =>
            TermTry(expr, cases, finallyp)
          case Some(catchp) =>
            TermTryWithHandler(expr, catchp, finallyp)
          case None =>
            TermTry(expr, Nil, finallyp)
        }
      case THROW =>
        in.nextToken()
        TermThrow(term())
      case RETURN =>
        in.nextToken()
        val term = {
          if (in.token.isTermIntro) {
            Some(this.term())
          } else {
            None
          }
        }
        TermReturn(term)
      case FOR =>
        in.nextToken()
        val enumerators: List[Enumerator] = {
          if (in.token == LPAREN) {
            inParens(this.enumerators())
          } else if (in.token == LBRACE) {
            inBraces(this.enumerators())
          } else {
            accept(LPAREN)
            List()
          }
        }
        newLinesOpt()
        if (in.token == YIELD) {
          in.nextToken()
          val body = term()
          TermForYield(enumerators, body)
        } else {
          val body = term()
          TermFor(enumerators, body)
        }
      case _ =>
        val unfinished = postfixTerm()
        in.token match {
          case EQUALS =>
            unfinished match {
              case TermId(_) | TermSelect(_, _) | TermApply(_, _) =>
                in.nextToken()
                val lhs = unfinished
                val rhs = term()
                atPos(start)(TermAssign(lhs, rhs))
              case _ =>
                unfinished
            }
          case COLON =>
            in.nextToken()
            in.token match {
              case USCORE =>
                in.nextToken()
                if (in.token == ID && in.idValue == "*") {
                  in.nextToken()
                  TermRepeat(unfinished)
                } else {
                  val errOffset = in.offset
                  reportOffset(errOffset, ExpectedId(_, "*", in.token))
                  atPos(errOffset)(errorTerm())
                }
              case AT =>
                val term = unfinished
                val mods = termAnnotateMods()
                TermAnnotate(term, mods)
              case _ =>
                val term = unfinished
                val tpt = {
                  if (location == Elsewhere) this.tpt()
                  else this.infixTpt()
                }
                TermAscribe(term, tpt)
            }
          case MATCH =>
            in.nextToken()
            val term = unfinished
            TermMatch(term, inBraces(this.cases()))
          case _ =>
            unfinished
        }
    }
  }