================================================================================
Call expressions
================================================================================

class C {
  def main() {
    a()
    a(
      123,
      234,
    )
    ::(123)
    a(b, c)
    a.map(x => x + 1)
    a { 123 }
    a { b }
    a.map{ x => x + 1 }
    /* comment */ a.exists { case ((i, _)) => i }
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (parameters)
        (block
          (call_expression
            (identifier)
            (arguments))
          (call_expression
            (identifier)
            (arguments
              (integer_literal)
              (integer_literal)))
          (call_expression
            (operator_identifier)
            (arguments
              (integer_literal)))
          (call_expression
            (identifier)
            (arguments
              (identifier)
              (identifier)))
          (call_expression
            (field_expression
              (identifier)
              (identifier))
            (arguments
              (lambda_expression
                (identifier)
                (infix_expression
                  (identifier)
                  (operator_identifier)
                  (integer_literal)))))
          (call_expression
            (identifier)
            (block
              (integer_literal)))
          (call_expression
            (identifier)
            (block
              (identifier)))
          (call_expression
            (field_expression
              (identifier)
              (identifier))
            (block
              (lambda_expression
                (identifier)
                (infix_expression
                  (identifier)
                  (operator_identifier)
                  (integer_literal)))))
          (block_comment)
          (call_expression
            (field_expression
              (identifier)
              (identifier))
            (case_block
              (case_clause
                (tuple_pattern
                  (tuple_pattern
                    (identifier)
                    (wildcard)))
                (identifier)))))))))

================================================================================
Call expressions (Scala 3 syntax)
================================================================================

class C {
  a(b, c)(using A.B)

  foo(new A:
    def a = new B:
      def b = 1)
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (call_expression
        (call_expression
          (identifier)
          (arguments
            (identifier)
            (identifier)))
        (arguments
          (field_expression
            (identifier)
            (identifier))))
      (call_expression
        (identifier)
        (arguments
          (instance_expression
            (type_identifier)
            (template_body
              (function_definition
                (identifier)
                (instance_expression
                  (type_identifier)
                  (template_body
                    (function_definition
                      (identifier)
                      (integer_literal))))))))))))

================================================================================
SIP-44 Fewer braces (Scala 3 syntax)
================================================================================

class C:
  xs.map: x =>
    x + 1

  xs.map:
    x =>
      x + 1


  xs.map: (_: Int, a) =>
    a

  xs:
    println("")

  xs `++`:
    val x = 1
    List(x)

  xs.map:
    case x => x

  // This is ascription
  xs: Int
  // This is call_expression
  xs:
    Int

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (call_expression
        (field_expression
          (identifier)
          (identifier))
        (colon_argument
          (identifier)
          (indented_block
            (infix_expression
              (identifier)
              (operator_identifier)
              (integer_literal)))))
      (call_expression
        (field_expression
          (identifier)
          (identifier))
        (colon_argument
          (indented_block
            (lambda_expression
              (identifier)
              (indented_block
                (infix_expression
                  (identifier)
                  (operator_identifier)
                  (integer_literal)))))))
      (call_expression
        (field_expression
          (identifier)
          (identifier))
        (colon_argument
          (bindings
            (binding
              (wildcard)
              (type_identifier))
            (binding
              (identifier)))
          (indented_block
            (identifier))))
      (call_expression
        (identifier)
        (colon_argument
          (indented_block
            (call_expression
              (identifier)
              (arguments
                (string))))))
      (call_expression
        (postfix_expression
          (identifier)
          (identifier))
        (colon_argument
          (indented_block
            (val_definition
              (identifier)
              (integer_literal))
            (call_expression
              (identifier)
              (arguments
                (identifier))))))
      (call_expression
        (field_expression
          (identifier)
          (identifier))
        (colon_argument
          (indented_cases
            (case_clause
              (identifier)
              (identifier))
            (comment))))
      (ascription_expression
        (identifier)
        (type_identifier))
      (comment)
      (call_expression
        (identifier)
        (colon_argument
          (indented_block
            (identifier)))))))

================================================================================
Colon argument with a context function lambda
================================================================================

class C:
  me.foldUse(g): _ ?=>
    xs.filter(h)
  .topN(max)

  xs.foldUse(g): ctx ?=>
    val t = 1
    t

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (call_expression
        (field_expression
          (call_expression
            (call_expression
              (field_expression
                (identifier)
                (identifier))
              (arguments
                (identifier)))
            (colon_argument
              (wildcard)
              (indented_block
                (call_expression
                  (field_expression
                    (identifier)
                    (identifier))
                  (arguments
                    (identifier))))))
          (identifier))
        (arguments
          (identifier)))
      (call_expression
        (call_expression
          (field_expression
            (identifier)
            (identifier))
          (arguments
            (identifier)))
        (colon_argument
          (identifier)
          (indented_block
            (val_definition
              (identifier)
              (integer_literal))
            (identifier)))))))

================================================================================
Trailing comma after for comprehension in lambda parameter of a function
================================================================================

foo(o =>
    for {
      a <- o
    } yield a,
  )

--------------------------------------------------------------------------------

(compilation_unit
  (call_expression
    function: (identifier)
    arguments: (arguments
      (lambda_expression
        parameters: (identifier)
        (indented_block
          (for_expression
            enumerators: (enumerators
              (enumerator
                (identifier)
                (identifier)))
            body: (identifier)))))))

================================================================================
Leading infix operator at lower indent continues the expression across dedent
================================================================================

xs.filter(x =>
     a
  && b
)

--------------------------------------------------------------------------------

(compilation_unit
  (call_expression
    function: (field_expression
      value: (identifier)
      field: (identifier))
    arguments: (arguments
      (lambda_expression
        parameters: (identifier)
        (indented_block
          (infix_expression
            left: (identifier)
            operator: (operator_identifier)
            right: (identifier)))))))

================================================================================
Colon argument followed by comma
================================================================================

boxTop(
    back.map: url =>
      a(b),
    title,
    x match
      case a => a,
)

--------------------------------------------------------------------------------

(compilation_unit
  (call_expression
    (identifier)
    (arguments
      (call_expression
        (field_expression
          (identifier)
          (identifier))
        (colon_argument
          (identifier)
          (indented_block
            (call_expression
              (identifier)
              (arguments
                (identifier))))))
      (identifier)
      (match_expression
        (identifier)
        (indented_cases
          (case_clause
            (identifier)
            (identifier)))))))

================================================================================
Generic functions
================================================================================

class C {
  def main() {
    a[
      A1,
      A2,
    ]()
    List[Traversable[ClassPath]]()
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (parameters)
        (block
          (call_expression
            (generic_function
              (identifier)
              (type_arguments
                (type_identifier)
                (type_identifier)))
            (arguments))
          (call_expression
            (generic_function
              (identifier)
              (type_arguments
                (generic_type
                  (type_identifier)
                  (type_arguments
                    (type_identifier)))))
            (arguments)))))))

================================================================================
Assignments
================================================================================

a = b
a(1) = c
views =
  val key = 1
  key + 1

--------------------------------------------------------------------------------

(compilation_unit
  (assignment_expression
    (identifier)
    (identifier))
  (assignment_expression
    (call_expression
      (identifier)
      (arguments
        (integer_literal)))
    (identifier))
  (assignment_expression
    (identifier)
    (indented_block
      (val_definition
        (identifier)
        (integer_literal))
      (infix_expression
        (identifier)
        (operator_identifier)
        (integer_literal)))))

================================================================================
If expressions
================================================================================

class C {
  def main() {
    if (a) b()
    if (c) {
      d()
      e()
    } else if (f) {
      g()
    } else {
      h()
    }
  }
}

def other() {
  if (a) {
    b
  };
  else c()
}

def another() {
  if (a) b match {
    case _ => c
  } else d
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (parameters)
        (block
          (if_expression
            (parenthesized_expression
              (identifier))
            (call_expression
              (identifier)
              (arguments)))
          (if_expression
            (parenthesized_expression
              (identifier))
            (block
              (call_expression
                (identifier)
                (arguments))
              (call_expression
                (identifier)
                (arguments)))
            (if_expression
              (parenthesized_expression
                (identifier))
              (block
                (call_expression
                  (identifier)
                  (arguments)))
              (block
                (call_expression
                  (identifier)
                  (arguments)))))))))
  (function_definition
    (identifier)
    (parameters)
    (block
      (if_expression
        (parenthesized_expression
          (identifier))
        (block
          (identifier))
        (call_expression
          (identifier)
          (arguments)))))
  (function_definition
    (identifier)
    (parameters)
    (block
      (if_expression
        (parenthesized_expression
          (identifier))
        (match_expression
          (identifier)
          (case_block
            (case_clause
              (wildcard)
              (identifier))))
        (identifier)))))

================================================================================
If with a parenthesized condition and a next-line then (Scala 3 syntax)
================================================================================

def g =
  if (a)
  then x
  else y

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (if_expression
        (parenthesized_expression
          (identifier))
        (identifier)
        (identifier)))))

================================================================================
If expressions (Scala 3 syntax)
================================================================================

class C:
  def main() =
    if a then b()
    end if

    if
      val c = false
      c
    then
      d()
      1
    else if f then
      g()
    else
      h()

    if true then
      ()

    // comment
    else
      ()

    if (a) || b(c) then return true

    if (a) && b.c then
      ()

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (parameters)
        (indented_block
          (if_expression
            (identifier)
            (call_expression
              (identifier)
              (arguments))
            (end_marker))
          (if_expression
            (indented_block
              (val_definition
                (identifier)
                (boolean_literal))
              (identifier))
            (indented_block
              (call_expression
                (identifier)
                (arguments))
              (integer_literal))
            (if_expression
              (identifier)
              (indented_block
                (call_expression
                  (identifier)
                  (arguments)))
              (indented_block
                (call_expression
                  (identifier)
                  (arguments)))))
          (if_expression
            (boolean_literal)
            (indented_block
              (unit)
              (comment))
            (indented_block
              (unit)))
          (if_expression
            (infix_expression
              (parenthesized_expression
                (identifier))
              (operator_identifier)
              (call_expression
                (identifier)
                (arguments
                  (identifier))))
            (return_expression
              (boolean_literal)))
          (if_expression
            (infix_expression
              (parenthesized_expression
                (identifier))
              (operator_identifier)
              (field_expression
                (identifier)
                (identifier)))
            (indented_block
              (unit))))))))

================================================================================
Try expressions
================================================================================

def main() {
  try a() finally depth -= 1
  try {
    doThing()
  } catch {
    case e: SomeException => prinlnt(e.message)
    case NonFatal(ex) => throw new SomeException(ex)
  } finally {
    tryAnotherThing()
  }
  try b()
  catch { case e => println(e) }
  finally doFinalThing()
  try a()
  finally b()
}

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters)
    (block
      (try_expression
        (call_expression
          (identifier)
          (arguments))
        (finally_clause
          (infix_expression
            (identifier)
            (operator_identifier)
            (integer_literal))))
      (try_expression
        (block
          (call_expression
            (identifier)
            (arguments)))
        (catch_clause
          (case_block
            (case_clause
              (typed_pattern
                (identifier)
                (type_identifier))
              (call_expression
                (identifier)
                (arguments
                  (field_expression
                    (identifier)
                    (identifier)))))
            (case_clause
              (case_class_pattern
                (type_identifier)
                (identifier))
              (throw_expression
                (instance_expression
                  (type_identifier)
                  (arguments
                    (identifier)))))))
        (finally_clause
          (block
            (call_expression
              (identifier)
              (arguments)))))
      (try_expression
        (call_expression
          (identifier)
          (arguments))
        (catch_clause
          (case_block
            (case_clause
              (identifier)
              (call_expression
                (identifier)
                (arguments
                  (identifier))))))
        (finally_clause
          (call_expression
            (identifier)
            (arguments))))
      (try_expression
        (call_expression
          (identifier)
          (arguments))
        (finally_clause
          (call_expression
            (identifier)
            (arguments)))))))

================================================================================
Try expressions (Scala 3 syntax)
================================================================================

def main(): Unit =
  try a() finally depth -= 1

  try
    a()
    b()
  catch
    case e: SomeException => prinlnt(e.message)
    case NonFatal(ex)     => throw new SomeException(ex)
  finally
    tryAnotherThing()
    tryAnotherThing2()
  try a catch case b: C => e finally f
  try a catch case b: C =>
    e

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters)
    (type_identifier)
    (indented_block
      (try_expression
        (call_expression
          (identifier)
          (arguments))
        (finally_clause
          (infix_expression
            (identifier)
            (operator_identifier)
            (integer_literal))))
      (try_expression
        (indented_block
          (call_expression
            (identifier)
            (arguments))
          (call_expression
            (identifier)
            (arguments)))
        (catch_clause
          (indented_cases
            (case_clause
              (typed_pattern
                (identifier)
                (type_identifier))
              (call_expression
                (identifier)
                (arguments
                  (field_expression
                    (identifier)
                    (identifier)))))
            (case_clause
              (case_class_pattern
                (type_identifier)
                (identifier))
              (throw_expression
                (instance_expression
                  (type_identifier)
                  (arguments
                    (identifier)))))))
        (finally_clause
          (indented_block
            (call_expression
              (identifier)
              (arguments))
            (call_expression
              (identifier)
              (arguments)))))
      (try_expression
        (identifier)
        (catch_clause
          (typed_pattern
            (identifier)
            (type_identifier))
          (identifier))
        (finally_clause
          (identifier)))
      (try_expression
        (identifier)
        (catch_clause
          (typed_pattern
            (identifier)
            (type_identifier))
          (indented_block
            (identifier)))))))

================================================================================
Match expressions
================================================================================

def matchTest(x: Int): String = x match {
  case 0 =>
  case 1 => "one"; "uno"
  case 2 => "two"
  case 3 => {
    "3"
  }
  case 4 => 
    ;
  case A if a == 1 =>
  case A if a == 2 => 2
  case ((i, _)) => i
  case s"$l1 -- $l2" => 
    l1 + l2
  case _ =>
    val x = "many"
    "more"
  case a if b => c
}

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters
      (parameter
        (identifier)
        (type_identifier)))
    (type_identifier)
    (match_expression
      (identifier)
      (case_block
        (case_clause
          (integer_literal))
        (case_clause
          (integer_literal)
          (string)
          (string))
        (case_clause
          (integer_literal)
          (string))
        (case_clause
          (integer_literal)
          (block
            (string)))
        (case_clause
          (integer_literal))
        (case_clause
          (identifier)
          (guard
            (infix_expression
              (identifier)
              (operator_identifier)
              (integer_literal))))
        (case_clause
          (identifier)
          (guard
            (infix_expression
              (identifier)
              (operator_identifier)
              (integer_literal)))
          (integer_literal))
        (case_clause
          (tuple_pattern
            (tuple_pattern
              (identifier)
              (wildcard)))
          (identifier))
        (case_clause
          (interpolated_string_expression
            (identifier)
            (interpolated_string
              (interpolation
                (identifier))
              (interpolation
                (identifier))))
          (infix_expression
            (identifier)
            (operator_identifier)
            (identifier)))
        (case_clause
          (wildcard)
          (val_definition
            (identifier)
            (string))
          (string))
        (case_clause
          (identifier)
          (guard
            (identifier))
          (identifier))))))

================================================================================
Match expressions (Scala 3 syntax)
================================================================================

def matchTest(x: Int): String =
  x match
    case 0 =>
    case 1 => "one"; "uno"
    case 2 => "two"
    case x if x == 3 =>
      val x = "3"
      x
    case ((i, _)) => i
    case _ =>
      val x = "many"
      "more"

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters
      (parameter
        (identifier)
        (type_identifier)))
    (type_identifier)
    (indented_block
      (match_expression
        (identifier)
        (indented_cases
          (case_clause
            (integer_literal))
          (case_clause
            (integer_literal)
            (string)
            (string))
          (case_clause
            (integer_literal)
            (string))
          (case_clause
            (identifier)
            (guard
              (infix_expression
                (identifier)
                (operator_identifier)
                (integer_literal)))
            (val_definition
              (identifier)
              (string))
            (identifier))
          (case_clause
            (tuple_pattern
              (tuple_pattern
                (identifier)
                (wildcard)))
            (identifier))
          (case_clause
            (wildcard)
            (val_definition
              (identifier)
              (string))
            (string)))))))

================================================================================
Dot-syntax for match expressions (Scala 3 syntax)
================================================================================

def matchTest(x: Int): String =
  x
   .find()
   .match
     case 0 =>
     case 1 => 
   .run()

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters
      (parameter
        (identifier)
        (type_identifier)))
    (type_identifier)
    (indented_block
      (call_expression
        (field_expression
          (match_expression
            (call_expression
              (field_expression
                (identifier)
                (identifier))
              (arguments))
            (indented_cases
              (case_clause
                (integer_literal))
              (case_clause
                (integer_literal))))
          (identifier))
        (arguments)))))

================================================================================
Field expressions
================================================================================

class C {
  def main() {
    a.b = c
    a.b.d
    a
      .b
      // comment1
      /* 
         comment2 
      */
      .c
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (parameters)
        (block
          (assignment_expression
            (field_expression
              (identifier)
              (identifier))
            (identifier))
          (field_expression
            (field_expression
              (identifier)
              (identifier))
            (identifier))
          (field_expression
            (field_expression
              (identifier)
              (identifier))
            (comment)
            (block_comment)
            (identifier)))))))

================================================================================
Instance expressions
================================================================================

class C {
  def main() {
    val a = new B
    val c = new D(e, f)
    val e = new E:
      def app = 1
    val f = new:
      def app = 1
    val g = new G {}
    val i = new {
      "ok"
    }
    new Array: Array
    new T.T with A
    new T.T[B](a) with A
    new {
      val a: Int = 1
    } with C with D
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (parameters)
        (block
          (val_definition
            (identifier)
            (instance_expression
              (type_identifier)))
          (val_definition
            (identifier)
            (instance_expression
              (type_identifier)
              (arguments
                (identifier)
                (identifier))))
          (val_definition
            (identifier)
            (instance_expression
              (type_identifier)
              (template_body
                (function_definition
                  (identifier)
                  (integer_literal)))))
          (val_definition
            (identifier)
            (instance_expression
              (template_body
                (function_definition
                  (identifier)
                  (integer_literal)))))
          (val_definition
            (identifier)
            (instance_expression
              (type_identifier)
              (template_body)))
          (val_definition
            (identifier)
            (instance_expression
              (template_body
                (string))))
          (ascription_expression
            (instance_expression
              (type_identifier))
            (type_identifier))
          (instance_expression
            (compound_type
              (stable_type_identifier
                (identifier)
                (type_identifier))
              (type_identifier)))
          (instance_expression
            (compound_type
              (applied_constructor_type
                (generic_type
                  (stable_type_identifier
                    (identifier)
                    (type_identifier))
                  (type_arguments
                    (type_identifier)))
                (arguments
                  (identifier)))
              (type_identifier)))
          (instance_expression
            (early_defs
              (val_definition
                (identifier)
                (type_identifier)
                (integer_literal)))
            (compound_type
              (type_identifier)
              (type_identifier))))))))

================================================================================
Infix expressions
================================================================================

class C {
  def main() {
    a = b max c
    d + e + f
    a ** b
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (parameters)
        (block
          (assignment_expression
            (identifier)
            (infix_expression
              (identifier)
              (identifier)
              (identifier)))
          (infix_expression
            (infix_expression
              (identifier)
              (operator_identifier)
              (identifier))
            (operator_identifier)
            (identifier))
          (infix_expression
            (identifier)
            (operator_identifier)
            (identifier)))))))

================================================================================
Multi-line infix expressions with leading infix operators
================================================================================

def foo =
  a
  || b
  && c
  `in` d

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (infix_expression
        (infix_expression
          (identifier)
          (operator_identifier)
          (infix_expression
            (identifier)
            (operator_identifier)
            (identifier)))
        (identifier)
        (identifier)))))

================================================================================
Prefix expressions
================================================================================

class C {
  def main() {
    !a
    +a + b
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (parameters)
        (block
          (prefix_expression
            (identifier))
          (infix_expression
            (prefix_expression
              (identifier))
            (operator_identifier)
            (identifier)))))))

================================================================================
??? as standalone statement
================================================================================

final def a =
  println(1)
  ???

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (modifiers)
    name: (identifier)
    body: (indented_block
      (call_expression
        function: (identifier)
        arguments: (arguments
          (integer_literal)))
      (operator_identifier))))

================================================================================
Postfix expressions
================================================================================

object O {
  val v = "value" toUpperCase
  val c = 1 + 2 toString
}

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (val_definition
        (identifier)
        (postfix_expression
          (string)
          (identifier)))
      (val_definition
        (identifier)
        (postfix_expression
          (infix_expression
            (integer_literal)
            (operator_identifier)
            (integer_literal))
          (identifier))))))

================================================================================
Ascription Expression
================================================================================

object O {
  val l = a: List
  val x = 2: Byte
  Nil: List[String]
  x: @unchecked
}

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (val_definition
        (identifier)
        (ascription_expression
          (identifier)
          (type_identifier)))
      (val_definition
        (identifier)
        (ascription_expression
          (integer_literal)
          (type_identifier)))
      (ascription_expression
        (identifier)
        (generic_type
          (type_identifier)
          (type_arguments
            (type_identifier))))
      (ascription_expression
        (identifier)
        (annotation
          (type_identifier))))))

================================================================================
Lambda Expression
================================================================================

object O {
  val l = a => a + 1
  val b = (x: Int, y: Int) => { x * y }
  val f = _ => 2
  foo { i => 
    val x = 2 + i 
    x
  }
  { x => 
    val y = 2 * x
    y * y
  }
  { b =>
   if (c) d.e }
  { a => implicit b => b }
  { (_, a) => a }
  { x: Int => x + 1 }
  { () => val x = 1; 2 }
  { () => val tp = qual.tpe; val sym = tp.typeSymbolDirect
    1
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (val_definition
        (identifier)
        (lambda_expression
          (identifier)
          (infix_expression
            (identifier)
            (operator_identifier)
            (integer_literal))))
      (val_definition
        (identifier)
        (lambda_expression
          (bindings
            (binding
              (identifier)
              (type_identifier))
            (binding
              (identifier)
              (type_identifier)))
          (block
            (infix_expression
              (identifier)
              (operator_identifier)
              (identifier)))))
      (val_definition
        (identifier)
        (lambda_expression
          (wildcard)
          (integer_literal)))
      (call_expression
        (identifier)
        (block
          (lambda_expression
            (identifier)
            (indented_block
              (val_definition
                (identifier)
                (infix_expression
                  (integer_literal)
                  (operator_identifier)
                  (identifier)))
              (identifier)))))
      (block
        (lambda_expression
          (identifier)
          (indented_block
            (val_definition
              (identifier)
              (infix_expression
                (integer_literal)
                (operator_identifier)
                (identifier)))
            (infix_expression
              (identifier)
              (operator_identifier)
              (identifier)))))
      (block
        (lambda_expression
          (identifier)
          (indented_block
            (if_expression
              (parenthesized_expression
                (identifier))
              (field_expression
                (identifier)
                (identifier))))))
      (block
        (lambda_expression
          (identifier)
          (lambda_expression
            (identifier)
            (identifier))))
      (block
        (lambda_expression
          (bindings
            (binding
              (wildcard))
            (binding
              (identifier)))
          (identifier)))
      (block
        (lambda_expression
          (identifier)
          (type_identifier)
          (infix_expression
            (identifier)
            (operator_identifier)
            (integer_literal))))
      (block
        (lambda_expression
          (bindings)
          (val_definition
            (identifier)
            (integer_literal))
          (integer_literal)))
      (block
        (lambda_expression
          (bindings)
          (val_definition
            (identifier)
            (field_expression
              (identifier)
              (identifier)))
          (val_definition
            (identifier)
            (field_expression
              (identifier)
              (identifier)))
          (integer_literal))))))

================================================================================
Lambda Expression (Scala 3 syntax)
================================================================================

object O:
  val f = (a: Int) ?=> (b: Int) => b

  val less: Comparer = [X: Ord] => (x: X, y: X) => ???

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (val_definition
        (identifier)
        (lambda_expression
          (bindings
            (binding
              (identifier)
              (type_identifier)))
          (lambda_expression
            (bindings
              (binding
                (identifier)
                (type_identifier)))
            (identifier))))
      (val_definition
        (identifier)
        (type_identifier)
        (lambda_expression
          (type_parameters
            (identifier)
            (context_bound
              (type_identifier)))
          (bindings
            (binding
              (identifier)
              (type_identifier))
            (binding
              (identifier)
              (type_identifier)))
          (operator_identifier))))))

================================================================================
Unit expressions
================================================================================

val x = ()
def f(): Unit = { (   
); }

--------------------------------------------------------------------------------

(compilation_unit
  (val_definition
    (identifier)
    (unit))
  (function_definition
    (identifier)
    (parameters)
    (type_identifier)
    (block
      (unit))))

================================================================================
Return expressions
================================================================================

def f: Unit = return
def g(a: A): B = { f(); return null.asInstanceOf[B] }

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (type_identifier)
    (return_expression))
  (function_definition
    (identifier)
    (parameters
      (parameter
        (identifier)
        (type_identifier)))
    (type_identifier)
    (block
      (call_expression
        (identifier)
        (arguments))
      (return_expression
        (generic_function
          (field_expression
            (null_literal)
            (identifier))
          (type_arguments
            (type_identifier)))))))

================================================================================
While loops
================================================================================

def f = {
  while (a) g()
  while (b < c) {
    d
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (block
      (while_expression
        (parenthesized_expression
          (identifier))
        (call_expression
          (identifier)
          (arguments)))
      (while_expression
        (parenthesized_expression
          (infix_expression
            (identifier)
            (operator_identifier)
            (identifier)))
        (block
          (identifier))))))

================================================================================
While loops (Scala 3 syntax)
================================================================================

def f: Unit =
  while a do g()

  while
    val x = 1
    b < x
  do
    ()

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (type_identifier)
    (indented_block
      (while_expression
        (identifier)
        (call_expression
          (identifier)
          (arguments)))
      (while_expression
        (indented_block
          (val_definition
            (identifier)
            (integer_literal))
          (infix_expression
            (identifier)
            (operator_identifier)
            (identifier)))
        (indented_block
          (unit))))))

================================================================================
Do-while loops
================================================================================

def f() = {
  do g(a, b) while(c && d)
  do {
    g(a, b)
    h(a, b)
  } while (c < d)
}

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters)
    (block
      (do_while_expression
        (call_expression
          (identifier)
          (arguments
            (identifier)
            (identifier)))
        (parenthesized_expression
          (infix_expression
            (identifier)
            (operator_identifier)
            (identifier))))
      (do_while_expression
        (block
          (call_expression
            (identifier)
            (arguments
              (identifier)
              (identifier)))
          (call_expression
            (identifier)
            (arguments
              (identifier)
              (identifier))))
        (parenthesized_expression
          (infix_expression
            (identifier)
            (operator_identifier)
            (identifier)))))))

================================================================================
Do-while in assignment and return positions
================================================================================

object O {
  var w = 0
  w = do step() while (cond)
  def r: Unit = { return do step() while (cond) }
}

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (var_definition
        (identifier)
        (integer_literal))
      (assignment_expression
        (identifier)
        (do_while_expression
          (call_expression
            (identifier)
            (arguments))
          (parenthesized_expression
            (identifier))))
      (function_definition
        (identifier)
        (type_identifier)
        (block
          (return_expression
            (do_while_expression
              (call_expression
                (identifier)
                (arguments))
              (parenthesized_expression
                (identifier)))))))))

================================================================================
Do-while in statement positions
================================================================================

do g() while (c)

val v = do g() while (c)

def f =
  h()
  do g() while (c)
  1

--------------------------------------------------------------------------------

(compilation_unit
  (do_while_expression
    (call_expression
      (identifier)
      (arguments))
    (parenthesized_expression
      (identifier)))
  (val_definition
    (identifier)
    (do_while_expression
      (call_expression
        (identifier)
        (arguments))
      (parenthesized_expression
        (identifier))))
  (function_definition
    (identifier)
    (indented_block
      (call_expression
        (identifier)
        (arguments))
      (do_while_expression
        (call_expression
          (identifier)
          (arguments))
        (parenthesized_expression
          (identifier)))
      (integer_literal))))

================================================================================
For comprehensions
================================================================================

def f() = {
  for (n <- nums) yield n + 1
  for (x <- xs; y <- ys) g(x, y)
  for {
    x <- xs
    a = b + c
    y <- g() if d
    (t, u) = y
  } yield {
    h(x, y)
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters)
    (block
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (identifier)))
        (infix_expression
          (identifier)
          (operator_identifier)
          (integer_literal)))
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (identifier))
          (enumerator
            (identifier)
            (identifier)))
        (call_expression
          (identifier)
          (arguments
            (identifier)
            (identifier))))
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (identifier))
          (enumerator
            (identifier)
            (infix_expression
              (identifier)
              (operator_identifier)
              (identifier)))
          (enumerator
            (identifier)
            (call_expression
              (identifier)
              (arguments))
            (guard
              (identifier)))
          (enumerator
            (tuple_pattern
              (identifier)
              (identifier))
            (identifier)))
        (block
          (call_expression
            (identifier)
            (arguments
              (identifier)
              (identifier))))))))

================================================================================
For comprehension enumerator with an indented block
================================================================================

def f =
  for
    u <-
      val a = g()
      a.h
    _ =
      p()
      q()
  yield u

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (indented_block
              (val_definition
                (identifier)
                (call_expression
                  (identifier)
                  (arguments)))
              (field_expression
                (identifier)
                (identifier))))
          (enumerator
            (wildcard)
            (indented_block
              (call_expression
                (identifier)
                (arguments))
              (call_expression
                (identifier)
                (arguments)))))
        (identifier)))))

================================================================================
For comprehensions (Scala 3 syntax)
================================================================================

def f(): Unit =
  for n <- nums yield n + 1

  for
    a = 1
    x <- xs
    y <- ys
  yield
    g(x, y)

  for
    annot <- annotations
    if shouldEmitAnnotation(annot)
  do
    ()
--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters)
    (type_identifier)
    (indented_block
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (identifier)))
        (infix_expression
          (identifier)
          (operator_identifier)
          (integer_literal)))
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (integer_literal))
          (enumerator
            (identifier)
            (identifier))
          (enumerator
            (identifier)
            (identifier)))
        (indented_block
          (call_expression
            (identifier)
            (arguments
              (identifier)
              (identifier)))))
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (identifier))
          (enumerator
            (guard
              (call_expression
                (identifier)
                (arguments
                  (identifier))))))
        (indented_block
          (unit))))))

================================================================================
Chained expressions
================================================================================

def main() {
  val myList = List(1, 2, 3)

  myList.map(_ * 2)

  myList
    .map(_ * 2)

  myList
    .length
}

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters)
    (block
      (val_definition
        (identifier)
        (call_expression
          (identifier)
          (arguments
            (integer_literal)
            (integer_literal)
            (integer_literal))))
      (call_expression
        (field_expression
          (identifier)
          (identifier))
        (arguments
          (infix_expression
            (wildcard)
            (operator_identifier)
            (integer_literal))))
      (call_expression
        (field_expression
          (identifier)
          (identifier))
        (arguments
          (infix_expression
            (wildcard)
            (operator_identifier)
            (integer_literal))))
      (field_expression
        (identifier)
        (identifier)))))

================================================================================
Macros (Scala 2 syntax)
================================================================================

class Foo {
  def a: A =
    macro B.b
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (type_identifier)
        (indented_block
          (macro_body
            (field_expression
              (identifier)
              (identifier))))))))

================================================================================
Macros (Scala 3 syntax)
================================================================================

class A:
  inline def inspect(inline a: Any): Any =
    ${ inspectCode('a) }

  def foo =
    '{ $b }

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (modifiers
          (inline_modifier))
        (identifier)
        (parameters
          (parameter
            (inline_modifier)
            (identifier)
            (type_identifier)))
        (type_identifier)
        (indented_block
          (splice_expression
            (call_expression
              (identifier)
              (arguments
                (quote_expression
                  (identifier)))))))
      (function_definition
        (identifier)
        (indented_block
          (quote_expression
            (identifier)))))))

================================================================================
Inline matches (Scala 3)
================================================================================

def hello = 
  inline c match {
    case 1 => 
  }

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (match_expression
        (inline_modifier)
        (identifier)
        (case_block
          (case_clause
            (integer_literal)))))))

================================================================================
Inline if (Scala 3)
================================================================================

def hello =
  inline if (x) {} else {}

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (if_expression
        (inline_modifier)
        (parenthesized_expression
          (identifier))
        (block)
        (block)))))

================================================================================
Nested inline if and match (Scala 3)
================================================================================

def hello =
  inline if (x) {
    inline x match {

    }
  }

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (if_expression
        (inline_modifier)
        (parenthesized_expression
          (identifier))
        (block
          (match_expression
            (inline_modifier)
            (identifier)
            (case_block)))))))

================================================================================
Top-level expressions
================================================================================

var greeting = "Good bye"
greeting = "Hello"
val message = greeting + " from Scala script!"

if true then
  println(message)

addSbtPlugin("foo" % "bar" % "0.1")

--------------------------------------------------------------------------------

(compilation_unit
  (var_definition
    (identifier)
    (string))
  (assignment_expression
    (identifier)
    (string))
  (val_definition
    (identifier)
    (infix_expression
      (identifier)
      (operator_identifier)
      (string)))
  (if_expression
    (boolean_literal)
    (indented_block
      (call_expression
        (identifier)
        (arguments
          (identifier)))))
  (call_expression
    (identifier)
    (arguments
      (infix_expression
        (infix_expression
          (string)
          (operator_identifier)
          (string))
        (operator_identifier)
        (string)))))

================================================================================
Soft keywords used as identifiers (Scala 3)
================================================================================
infix()
opaque()
open()
transparent()
as()
derives()
end()
throws()
using()

--------------------------------------------------------------------------------

(compilation_unit
  (call_expression
    (identifier)
    (arguments))
  (call_expression
    (identifier)
    (arguments))
  (call_expression
    (identifier)
    (arguments))
  (call_expression
    (identifier)
    (arguments))
  (call_expression
    (identifier)
    (arguments))
  (call_expression
    (identifier)
    (arguments))
  (call_expression
    (identifier)
    (arguments))
  (call_expression
    (identifier)
    (arguments))
  (call_expression
    (identifier)
    (arguments)))

================================================================================
Compound expression with instance declaration, pattern matching with guards and if statement
================================================================================

new Foo {
  tree match {
    case Foo if foos contains foo =>
      if (foo) bar
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (instance_expression
    (type_identifier)
    (template_body
      (match_expression
        (identifier)
        (case_block
          (case_clause
            (identifier)
            (guard
              (infix_expression
                (identifier)
                (identifier)
                (identifier)))
            (if_expression
              (parenthesized_expression
                (identifier))
              (identifier))))))))

================================================================================
Vararg expressions
================================================================================

foo(args*)
bar(xs: _*)
foo(a, args*)
bar(a, xs: _*)

--------------------------------------------------------------------------------

(compilation_unit
  (call_expression
    function: (identifier)
    arguments: (arguments
      (vararg
        (identifier))))
  (call_expression
    function: (identifier)
    arguments: (arguments
      (vararg
        (identifier))))
  (call_expression
    function: (identifier)
    arguments: (arguments
      (identifier)
      (vararg
        (identifier))))
  (call_expression
    function: (identifier)
    arguments: (arguments
      (identifier)
      (vararg
        (identifier)))))

================================================================================
Catch case with a multi-statement indented body
================================================================================

// https://github.com/tree-sitter/tree-sitter-scala/issues/542
try
  ???
catch case ex: Throwable =>
  val test = 123
  println(test)
finally
  cleanup()

---

(compilation_unit
  (comment)
  (try_expression
    (indented_block
      (operator_identifier))
    (catch_clause
      (typed_pattern
        (identifier)
        (type_identifier))
      (indented_block
        (val_definition
          (identifier)
          (integer_literal))
        (call_expression
          (identifier)
          (arguments
            (identifier)))))
    (finally_clause
      (indented_block
        (call_expression
          (identifier)
          (arguments))))))

================================================================================
Lambda with an empty body
================================================================================

object A {
  def g = persist(evt) { _ =>
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (call_expression
          (call_expression
            (identifier)
            (arguments
              (identifier)))
          (block
            (lambda_expression
              (wildcard))))))))

================================================================================
Soft keyword `end` as identifier in expressions
================================================================================

def f = {
  val end = 1
  println(s"took: ${end - start}ms")
  end - start
}

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (block
      (val_definition
        (identifier)
        (integer_literal))
      (call_expression
        (identifier)
        (arguments
          (interpolated_string_expression
            (identifier)
            (interpolated_string
              (interpolation
                (block
                  (infix_expression
                    (identifier)
                    (operator_identifier)
                    (identifier))))))))
      (infix_expression
        (identifier)
        (operator_identifier)
        (identifier)))))

================================================================================
End markers on control expressions (Scala 3 syntax)
================================================================================

def p() =
  if a then
    b
  end if
  while a do
    b
  end while
  for x <- xs do
    x
  end for
  try
    a
  catch
    case e => b
  end try
end p

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters)
    (indented_block
      (if_expression
        (identifier)
        (indented_block
          (identifier))
        (end_marker))
      (while_expression
        (identifier)
        (indented_block
          (identifier))
        (end_marker))
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (identifier)))
        (indented_block
          (identifier))
        (end_marker))
      (try_expression
        (indented_block
          (identifier))
        (catch_clause
          (indented_cases
            (case_clause
              (identifier)
              (identifier))))
        (end_marker)))
    (end_marker)))

================================================================================
Braced typed lambda and a colon-argument lambda
================================================================================

val a = forAll { int: Int =>
  int.asJson
}

val b = OWrites: c =>
  Json.obj(c)

--------------------------------------------------------------------------------

(compilation_unit
  (val_definition
    (identifier)
    (call_expression
      (identifier)
      (block
        (lambda_expression
          (identifier)
          (type_identifier)
          (indented_block
            (field_expression
              (identifier)
              (identifier)))))))
  (val_definition
    (identifier)
    (call_expression
      (identifier)
      (colon_argument
        (identifier)
        (indented_block
          (call_expression
            (field_expression
              (identifier)
              (identifier))
            (arguments
              (identifier))))))))

================================================================================
Standalone end is not a marker (Scala 3 syntax)
================================================================================

end Foo

--------------------------------------------------------------------------------

(compilation_unit
  (postfix_expression
    (identifier)
    (identifier)))

================================================================================
Soft keyword `inline` as identifier in expressions
================================================================================

val a = !inline || b
val c = inline && b

--------------------------------------------------------------------------------

(compilation_unit
  (val_definition
    (identifier)
    (infix_expression
      (prefix_expression
        (identifier))
      (operator_identifier)
      (identifier)))
  (val_definition
    (identifier)
    (infix_expression
      (identifier)
      (operator_identifier)
      (identifier))))

================================================================================
Unicode fat arrow (Scala 2)
================================================================================

import a.{b ⇒ c}

object A {
  val x = xs.map { case (k, v) ⇒ k }
  val y = xs.map(v ⇒ v)
  def f(g: ⇒ Int): Int ⇒ Int = h ⇒ g
}

--------------------------------------------------------------------------------

(compilation_unit
  (import_declaration
    (identifier)
    (namespace_selectors
      (arrow_renamed_identifier
        (identifier)
        (identifier))))
  (object_definition
    (identifier)
    (template_body
      (val_definition
        (identifier)
        (call_expression
          (field_expression
            (identifier)
            (identifier))
          (case_block
            (case_clause
              (tuple_pattern
                (identifier)
                (identifier))
              (identifier)))))
      (val_definition
        (identifier)
        (call_expression
          (field_expression
            (identifier)
            (identifier))
          (arguments
            (lambda_expression
              (identifier)
              (identifier)))))
      (function_definition
        (identifier)
        (parameters
          (parameter
            (identifier)
            (lazy_parameter_type
              (type_identifier))))
        (function_type
          (parameter_types
            (type_identifier))
          (type_identifier))
        (lambda_expression
          (identifier)
          (identifier))))))

================================================================================
Method values (eta expansion underscore)
================================================================================

val h = f _
def g(s: S) = (iso.reverseGet _ compose iso.get)(s) <==> s

--------------------------------------------------------------------------------

(compilation_unit
  (val_definition
    (identifier)
    (method_value
      (identifier)
      (wildcard)))
  (function_definition
    (identifier)
    (parameters
      (parameter
        (identifier)
        (type_identifier)))
    (infix_expression
      (call_expression
        (parenthesized_expression
          (infix_expression
            (method_value
              (field_expression
                (identifier)
                (identifier))
              (wildcard))
            (identifier)
            (field_expression
              (identifier)
              (identifier))))
        (arguments
          (identifier)))
      (operator_identifier)
      (identifier))))

================================================================================
Quoted keyword literals (Scala 3)
================================================================================

inline def e(inline m: String): Unit =
  ${ impl('m, 'null, 'true, 'false, 'this) }

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (modifiers
      (inline_modifier))
    (identifier)
    (parameters
      (parameter
        (inline_modifier)
        (identifier)
        (type_identifier)))
    (type_identifier)
    (indented_block
      (splice_expression
        (call_expression
          (identifier)
          (arguments
            (quote_expression
              (identifier))
            (quote_expression
              (null_literal))
            (quote_expression
              (boolean_literal))
            (quote_expression
              (boolean_literal))
            (quote_expression
              (identifier))))))))

================================================================================
Type bindings in a quote type block (Scala 3)
================================================================================

def types(t: Type[?])(using Quotes) = t match {
  case '[type x <: AnyKind; x] =>
  case '[ type t <: Tuple; *:[t, t] ] =>
  case '[
    type t
    type u
    Map[t, u]
  ] =>
}

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters
      (parameter
        (identifier)
        (generic_type
          (type_identifier)
          (type_arguments
            (type_identifier)))))
    (parameters
      (type_identifier))
    (match_expression
      (identifier)
      (case_block
        (case_clause
          (quote_expression
            (type_definition
              (type_identifier)
              (upper_bound
                (type_identifier)))
            (type_identifier)))
        (case_clause
          (quote_expression
            (type_definition
              (type_identifier)
              (upper_bound
                (type_identifier)))
            (generic_type
              (type_identifier)
              (type_arguments
                (type_identifier)
                (type_identifier)))))
        (case_clause
          (quote_expression
            (type_definition
              (type_identifier))
            (type_definition
              (type_identifier))
            (generic_type
              (type_identifier)
              (type_arguments
                (type_identifier)
                (type_identifier)))))))))

================================================================================
Empty statements before a statement
================================================================================

object A {
  def f = {
    val x = 1
    ;{
      val y = 2
    }
  }
  ;def g = 1
  def h = { ;; }
}

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (block
          (val_definition
            (identifier)
            (integer_literal))
          (block
            (val_definition
              (identifier)
              (integer_literal)))))
      (function_definition
        (identifier)
        (integer_literal))
      (function_definition
        (identifier)
        (block)))))

================================================================================
Parenthesized for with do, and yield on the next line
================================================================================

def f =
  for ((a, b) <- xs) do
    g(a)
  for (param <- params; idx <- indices(param))
  yield param.name
  for (typearg <- tree.typeargs)
  do
    h(typearg)

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (for_expression
        (enumerators
          (enumerator
            (tuple_pattern
              (identifier)
              (identifier))
            (identifier)))
        (indented_block
          (call_expression
            (identifier)
            (arguments
              (identifier)))))
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (identifier))
          (enumerator
            (identifier)
            (call_expression
              (identifier)
              (arguments
                (identifier)))))
        (field_expression
          (identifier)
          (identifier)))
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (field_expression
              (identifier)
              (identifier))))
        (indented_block
          (call_expression
            (identifier)
            (arguments
              (identifier))))))))

================================================================================
Lambda with a function-typed parameter
================================================================================

val f = (g: Int => Int) => g(1)
val h = xs.map((acc: Int => Int, x) => acc)

--------------------------------------------------------------------------------

(compilation_unit
  (val_definition
    pattern: (identifier)
    value: (lambda_expression
      parameters: (bindings
        (binding
          name: (identifier)
          type: (function_type
            parameter_types: (parameter_types
              (type_identifier))
            return_type: (type_identifier))))
      (call_expression
        function: (identifier)
        arguments: (arguments
          (integer_literal)))))
  (val_definition
    pattern: (identifier)
    value: (call_expression
      function: (field_expression
        value: (identifier)
        field: (identifier))
      arguments: (arguments
        (lambda_expression
          parameters: (bindings
            (binding
              name: (identifier)
              type: (function_type
                parameter_types: (parameter_types
                  (type_identifier))
                return_type: (type_identifier)))
            (binding
              name: (identifier)))
          (identifier))))))

================================================================================
Ascription to function types
================================================================================

object A {
  val a = (this.unsubscribe: ActorRef => Unit)
  val b = (fooMock.overloaded[Double]: Double => String).expects(1.0)
  val c = PriorityGenerator({ case 1 => 2 }: Any => Int)
  val d = (1 second: Duration)
  val e = (identity _ : Int => Int)
  val f = (handler: String => Context ?=> String)
}

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (val_definition
        (identifier)
        (parenthesized_expression
          (ascription_expression
            (field_expression
              (identifier)
              (identifier))
            (type_identifier)
            (type_identifier))))
      (val_definition
        (identifier)
        (call_expression
          (field_expression
            (parenthesized_expression
              (ascription_expression
                (generic_function
                  (field_expression
                    (identifier)
                    (identifier))
                  (type_arguments
                    (type_identifier)))
                (type_identifier)
                (type_identifier)))
            (identifier))
          (arguments
            (floating_point_literal))))
      (val_definition
        (identifier)
        (call_expression
          (identifier)
          (arguments
            (ascription_expression
              (case_block
                (case_clause
                  (integer_literal)
                  (integer_literal)))
              (type_identifier)
              (type_identifier)))))
      (val_definition
        (identifier)
        (parenthesized_expression
          (ascription_expression
            (postfix_expression
              (integer_literal)
              (identifier))
            (type_identifier))))
      (val_definition
        (identifier)
        (parenthesized_expression
          (ascription_expression
            (method_value
              (identifier)
              (wildcard))
            (type_identifier)
            (type_identifier))))
      (val_definition
        (identifier)
        (parenthesized_expression
          (ascription_expression
            (identifier)
            (type_identifier)
            (type_identifier)
            (type_identifier)))))))

================================================================================
Ascribed match expression (`}: @unchecked`)
================================================================================

def f =
  val (a, b) = info match {
    case Poly(tps, cinfo) => (tps, cinfo)
    case cinfo => (Nil, cinfo)
  }: @unchecked
  a

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (val_definition
        (tuple_pattern
          (identifier)
          (identifier))
        (ascription_expression
          (match_expression
            (identifier)
            (case_block
              (case_clause
                (case_class_pattern
                  (type_identifier)
                  (identifier)
                  (identifier))
                (tuple_expression
                  (identifier)
                  (identifier)))
              (case_clause
                (identifier)
                (tuple_expression
                  (identifier)
                  (identifier)))))
          (annotation
            (type_identifier))))
      (identifier))))

================================================================================
Soft keyword extension used as an identifier
================================================================================

object A {
  def journal: ActorRef =
    extension.journalFor(null)
  def f = x match {
    case 1 =>
      extension.remove(name)
      Behaviors.same
  }
  val s = s"snapshot-${extension}"
}

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (type_identifier)
        (indented_block
          (call_expression
            (field_expression
              (identifier)
              (identifier))
            (arguments
              (null_literal)))))
      (function_definition
        (identifier)
        (match_expression
          (identifier)
          (case_block
            (case_clause
              (integer_literal)
              (call_expression
                (field_expression
                  (identifier)
                  (identifier))
                (arguments
                  (identifier)))
              (field_expression
                (identifier)
                (identifier))))))
      (val_definition
        (identifier)
        (interpolated_string_expression
          (identifier)
          (interpolated_string
            (interpolation
              (block
                (identifier)))))))))

================================================================================
Bare dollar identifier called with arguments
================================================================================

object A {
  def f = {
    $(s"$selector *[name=$fieldName]").fill.`with`(fieldValue)
    $(selector).submit()
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (block
          (call_expression
            (field_expression
              (field_expression
                (call_expression
                  (identifier)
                  (arguments
                    (interpolated_string_expression
                      (identifier)
                      (interpolated_string
                        (interpolation
                          (identifier))
                        (interpolation
                          (identifier))))))
                (identifier))
              (identifier))
            (arguments
              (identifier)))
          (call_expression
            (field_expression
              (call_expression
                (identifier)
                (arguments
                  (identifier)))
              (identifier))
            (arguments)))))))

================================================================================
Catch on the same indentation as the match cases in a try body
================================================================================

// https://github.com/tree-sitter/tree-sitter-scala/issues/540
try optag match
  case  _                                     => null
  catch case ex: ArithmeticException => null

--------------------------------------------------------------------------------

(compilation_unit
  (comment)
  (try_expression
    (match_expression
      (identifier)
      (indented_cases
        (case_clause
          (wildcard)
          (null_literal))))
    (catch_clause
      (typed_pattern
        (identifier)
        (type_identifier))
      (null_literal))))

================================================================================
Line-leading match continuing a method chain
================================================================================

def f =
  xs
    .partition(deepTest)
      // partition into full matches and head matches
    match
      case (Nil, partials) => partials
      case givenImports => givenImports

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (match_expression
        (call_expression
          (field_expression
            (identifier)
            (identifier))
          (arguments
            (identifier)))
        (comment)
        (indented_cases
          (case_clause
            (tuple_pattern
              (identifier)
              (identifier))
            (identifier))
          (case_clause
            (identifier)
            (identifier)))))))

================================================================================
Leading infix continuation after a line whose statement ends with a comment
================================================================================

def allowed =
  m.isDeprecated
  || sym.info.typeSymbol.match        // more ubiquity
     case dd.DummyImplicitClass => true
     case tps =>
       tps.isMarkerTrait // no members
       ||                // but consider NotGiven
       tps.hasAnnotation(x)
  || sym.info.isSingleton // DSL friendly
  || sym.info.isRefined // can't be expressed

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (infix_expression
        (field_expression
          (identifier)
          (identifier))
        (operator_identifier)
        (match_expression
          (field_expression
            (field_expression
              (identifier)
              (identifier))
            (identifier))
          (comment)
          (indented_cases
            (case_clause
              (stable_identifier
                (identifier)
                (identifier))
              (boolean_literal))
            (case_clause
              (identifier)
              (infix_expression
                (infix_expression
                  (infix_expression
                    (field_expression
                      (identifier)
                      (identifier))
                    (comment)
                    (operator_identifier)
                    (comment)
                    (call_expression
                      (field_expression
                        (identifier)
                        (identifier))
                      (arguments
                        (identifier))))
                  (operator_identifier)
                  (field_expression
                    (field_expression
                      (identifier)
                      (identifier))
                    (identifier)))
                (comment)
                (operator_identifier)
                (field_expression
                  (field_expression
                    (identifier)
                    (identifier))
                  (identifier))))
            (comment)))))))

================================================================================
Block comment closed by same-line code inside a braced body
================================================================================

class Foo {
  def a: Int = 1

 /** doc
  *
  */ override def apply(f: From) = super.apply(f)

  def flip: Int = 2
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (type_identifier)
        (integer_literal))
      (block_comment)
      (function_definition
        (modifiers)
        (identifier)
        (parameters
          (parameter
            (identifier)
            (type_identifier)))
        (call_expression
          (field_expression
            (identifier)
            (identifier))
          (arguments
            (identifier))))
      (function_definition
        (identifier)
        (type_identifier)
        (integer_literal)))))

================================================================================
Identifier starting with a keyword prefix at line start (`match_`)
================================================================================

def f = {
  val match_ = {
    treeCopy.Match(match0, match0.cases)
  }
  match_ setType B1.tpe
}

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (block
      (val_definition
        (identifier)
        (block
          (call_expression
            (field_expression
              (identifier)
              (identifier))
            (arguments
              (identifier)
              (field_expression
                (identifier)
                (identifier))))))
      (infix_expression
        (identifier)
        (identifier)
        (field_expression
          (identifier)
          (identifier))))))

================================================================================
Braceless match with cases at the same indentation
================================================================================

// https://github.com/tree-sitter/tree-sitter-scala/issues/264
object A:
  a match
  case b =>
  case c =>

def foo =
  name match
  case n: Int =>
    body1
    body2
  case _ =>
    body3
  done()

---

(compilation_unit
  (comment)
  (object_definition
    (identifier)
    (template_body
      (match_expression
        (identifier)
        (indented_cases
          (case_clause
            (identifier))
          (case_clause
            (identifier))))))
  (function_definition
    (identifier)
    (indented_block
      (match_expression
        (identifier)
        (indented_cases
          (case_clause
            (typed_pattern
              (identifier)
              (type_identifier))
            (identifier)
            (identifier))
          (case_clause
            (wildcard)
            (identifier))))
      (call_expression
        (identifier)
        (arguments)))))

================================================================================
Nested braceless match inside same-indentation cases
================================================================================

def f =
  x match
  case A(p) =>
    y match
    case B => b
    case _ => c
  case None => d

---

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (match_expression
        (identifier)
        (indented_cases
          (case_clause
            (case_class_pattern
              (type_identifier)
              (identifier))
            (match_expression
              (identifier)
              (indented_cases
                (case_clause
                  (identifier)
                  (identifier))
                (case_clause
                  (wildcard)
                  (identifier)))))
          (case_clause
            (identifier)
            (identifier)))))))

================================================================================
Comma-separated parents in an extends clause inside an indented block
================================================================================

def transformType =
  object reported extends TypeMap, IdentityCaptRefMap:
    def apply(t: Type) = t
  object toCapturing extends DeepTypeMap, SetupTypeMap {
    override def toString = "x"
  }
  reported(tp)

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (object_definition
        (identifier)
        (extends_clause
          (type_identifier)
          (type_identifier))
        (template_body
          (function_definition
            (identifier)
            (parameters
              (parameter
                (identifier)
                (type_identifier)))
            (identifier))))
      (object_definition
        (identifier)
        (extends_clause
          (type_identifier)
          (type_identifier))
        (template_body
          (function_definition
            (modifiers)
            (identifier)
            (string))))
      (call_expression
        (identifier)
        (arguments
          (identifier))))))

================================================================================
Comma-separated imports in an indented body
================================================================================

final class A:
  import B.*, C.*
  def f = 1

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (modifiers)
    (identifier)
    (template_body
      (import_declaration
        (identifier)
        (namespace_wildcard)
        (identifier)
        (namespace_wildcard))
      (function_definition
        (identifier)
        (integer_literal)))))

================================================================================
Indented argument block closed by the comma before the next argument
================================================================================

def f(xs: List[Int]) =
  assert(
    if xs.isEmpty then
      true
    else
      false, "fail")

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters
      (parameter
        (identifier)
        (generic_type
          (type_identifier)
          (type_arguments
            (type_identifier)))))
    (indented_block
      (call_expression
        (identifier)
        (arguments
          (if_expression
            (field_expression
              (identifier)
              (identifier))
            (indented_block
              (boolean_literal))
            (indented_block
              (boolean_literal)))
          (string))))))

================================================================================
A comment opener inside the next argument is not a comment
================================================================================

f(
  if p then
    1
  else
    2, g("http://x"))

--------------------------------------------------------------------------------

(compilation_unit
  (call_expression
    (identifier)
    (arguments
      (if_expression
        (identifier)
        (indented_block
          (integer_literal))
        (indented_block
          (integer_literal)))
      (call_expression
        (identifier)
        (arguments
          (string))))))

================================================================================
Brackets of the next argument do not count as the closer
================================================================================

f(
  if p then
    1
  else
    2, g('('))

--------------------------------------------------------------------------------

(compilation_unit
  (call_expression
    (identifier)
    (arguments
      (if_expression
        (identifier)
        (indented_block
          (integer_literal))
        (indented_block
          (integer_literal)))
      (call_expression
        (identifier)
        (arguments
          (character_literal))))))

================================================================================
Backquoted then on a leading infix continuation line
================================================================================

def f =
  val cond =
      x.exists(p)
  && q.`then`
  cond

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (val_definition
        (identifier)
        (indented_block
          (infix_expression
            (call_expression
              (field_expression
                (identifier)
                (identifier))
              (arguments
                (identifier)))
            (operator_identifier)
            (field_expression
              (identifier)
              (identifier)))))
      (identifier))))

================================================================================
Colon template body starting with a backquoted DSL statement
================================================================================

class T extends F:
  `empty list` should work
  more()

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (extends_clause
      (type_identifier))
    (template_body
      (infix_expression
        (identifier)
        (identifier)
        (identifier))
      (call_expression
        (identifier)
        (arguments)))))

================================================================================
Comment between match and its case clauses
================================================================================

def f =
  x match
  /* c */ case a => b

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (match_expression
        (identifier)
        (indented_cases
          (block_comment)
          (case_clause
            (identifier)
            (identifier)))))))

================================================================================
Dedented block comment before a continuation line
================================================================================

def f =
  xs
 /* c */ .map(g)

def h =
  val a = x
 /* c */ || y
  a

class A {
  def g: Int = 1
  def f = if (c) 1
 /* x */ else 2
}

val a = 1
/* c */ val b = 2

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (call_expression
        (field_expression
          (identifier)
          (block_comment)
          (identifier))
        (arguments
          (identifier)))))
  (function_definition
    (identifier)
    (indented_block
      (val_definition
        (identifier)
        (infix_expression
          (identifier)
          (block_comment)
          (operator_identifier)
          (identifier)))
      (identifier)))
  (class_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (type_identifier)
        (integer_literal))
      (function_definition
        (identifier)
        (if_expression
          (parenthesized_expression
            (identifier))
          (integer_literal)
          (block_comment)
          (integer_literal)))))
  (val_definition
    (identifier)
    (integer_literal))
  (block_comment)
  (val_definition
    (identifier)
    (integer_literal)))

================================================================================
Dedented leading infix operator closing into an enclosing conditional
================================================================================

def f =
  if xs.indexSatisfying(from = index): imp =>
      imp.selectors.exists(p)
  < nextImport then
    action()

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (if_expression
        (infix_expression
          (call_expression
            (call_expression
              (field_expression
                (identifier)
                (identifier))
              (arguments
                (assignment_expression
                  (identifier)
                  (identifier))))
            (colon_argument
              (identifier)
              (indented_block
                (call_expression
                  (field_expression
                    (field_expression
                      (identifier)
                      (identifier))
                    (identifier))
                  (arguments
                    (identifier))))))
          (operator_identifier)
          (identifier))
        (indented_block
          (call_expression
            (identifier)
            (arguments)))))))

================================================================================
Deeply nested bare colon arguments
================================================================================

def g =
  typeRest:
    infixTypeRest(inContextBound):
      refinedTypeRest:
        withTypeRest:
          annotTypeRest:
            simpleTypeRest(tuple)

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (call_expression
        (identifier)
        (colon_argument
          (indented_block
            (call_expression
              (call_expression
                (identifier)
                (arguments
                  (identifier)))
              (colon_argument
                (indented_block
                  (call_expression
                    (identifier)
                    (colon_argument
                      (indented_block
                        (call_expression
                          (identifier)
                          (colon_argument
                            (indented_block
                              (call_expression
                                (identifier)
                                (colon_argument
                                  (indented_block
                                    (call_expression
                                      (identifier)
                                      (arguments
                                        (identifier)))))))))))))))))))))

================================================================================
Fewer-braces colon followed by a trailing comment
================================================================================

def f =
  xs.foldLeft(z): // combine
    (acc, x) =>
      acc + x
  ys.map: /* elementwise */
    y =>
      y * 2

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (call_expression
        (call_expression
          (field_expression
            (identifier)
            (identifier))
          (arguments
            (identifier)))
        (comment)
        (colon_argument
          (indented_block
            (lambda_expression
              (bindings
                (binding
                  (identifier))
                (binding
                  (identifier)))
              (indented_block
                (infix_expression
                  (identifier)
                  (operator_identifier)
                  (identifier)))))))
      (call_expression
        (field_expression
          (identifier)
          (identifier))
        (block_comment)
        (colon_argument
          (indented_block
            (lambda_expression
              (identifier)
              (indented_block
                (infix_expression
                  (identifier)
                  (operator_identifier)
                  (integer_literal))))))))))

================================================================================
For with an enumerator continued after a trailing infix operator
================================================================================

// https://github.com/tree-sitter/tree-sitter-scala/issues/358
for
  _ <- a *>
       b
yield ()

--------------------------------------------------------------------------------

(compilation_unit
  (comment)
  (for_expression
    (enumerators
      (enumerator
        (wildcard)
        (infix_expression
          (identifier)
          (operator_identifier)
          (identifier))))
    (unit)))

================================================================================
If-then with a multiline condition continued by a leading infix operator
================================================================================

// https://github.com/tree-sitter/tree-sitter-scala/issues/541
if (false)
  || true
then
  print("true")

--------------------------------------------------------------------------------

(compilation_unit
  (comment)
  (if_expression
    (infix_expression
      (parenthesized_expression
        (boolean_literal))
      (operator_identifier)
      (boolean_literal))
    (indented_block
      (call_expression
        (identifier)
        (arguments
          (string))))))

================================================================================
Indented bodies starting with keyword-prefixed identifiers
================================================================================

def f =
  cdo(1)
  eyield(2)
  e+ x
  g()

def m =
  xs
  m|| x

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (call_expression
        (identifier)
        (arguments
          (integer_literal)))
      (call_expression
        (identifier)
        (arguments
          (integer_literal)))
      (infix_expression
        (identifier)
        (operator_identifier)
        (identifier))
      (call_expression
        (identifier)
        (arguments))))
  (function_definition
    (identifier)
    (indented_block
      (identifier)
      (infix_expression
        (identifier)
        (operator_identifier)
        (identifier)))))

================================================================================
Leading infix operator continuing inside colon-argument regions
================================================================================

def f: Boolean =
  trace(msg, show = true):
    noNotes:
      elems.exists(g)
  || !x.isTerminal
    && ifNotTried(x):
      val xelems = x.elems
      xelems.forall(h)

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (type_identifier)
    (indented_block
      (call_expression
        (call_expression
          (identifier)
          (arguments
            (identifier)
            (assignment_expression
              (identifier)
              (boolean_literal))))
        (colon_argument
          (indented_block
            (call_expression
              (identifier)
              (colon_argument
                (indented_block
                  (call_expression
                    (infix_expression
                      (call_expression
                        (field_expression
                          (identifier)
                          (identifier))
                        (arguments
                          (identifier)))
                      (operator_identifier)
                      (infix_expression
                        (prefix_expression
                          (field_expression
                            (identifier)
                            (identifier)))
                        (operator_identifier)
                        (call_expression
                          (identifier)
                          (arguments
                            (identifier)))))
                    (colon_argument
                      (indented_block
                        (val_definition
                          (identifier)
                          (field_expression
                            (identifier)
                            (identifier)))
                        (call_expression
                          (field_expression
                            (identifier)
                            (identifier))
                          (arguments
                            (identifier)))))))))))))))

================================================================================
Leading operator statements with trailing comments keep their block
================================================================================

def f =
  ??? // TODO
  println("x")

def g =
  ??? /* TODO */
  h()

def i =
  p || // c
  q

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (operator_identifier)
      (comment)
      (call_expression
        (identifier)
        (arguments
          (string)))))
  (function_definition
    (identifier)
    (indented_block
      (operator_identifier)
      (block_comment)
      (call_expression
        (identifier)
        (arguments))))
  (function_definition
    (identifier)
    (indented_block
      (infix_expression
        (identifier)
        (operator_identifier)
        (comment)
        (identifier)))))

================================================================================
Mid-line else after an indented consequence
================================================================================

// https://github.com/tree-sitter/tree-sitter-scala/issues/539
def a = if (true)
  1 else 2

--------------------------------------------------------------------------------

(compilation_unit
  (comment)
  (function_definition
    (identifier)
    (if_expression
      (parenthesized_expression
        (boolean_literal))
      (indented_block
        (integer_literal))
      (integer_literal))))

================================================================================
Mid-line else and finally after a brace-less if
================================================================================

object A {
  def f =
    if (c)
      x match {
        case 1 => 1
      } else 2
  def g = {
    try if (force) graduates.removeIf(notAlive)
    finally if (locked) gcStatus.set(false)
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (function_definition
        (identifier)
        (indented_block
          (if_expression
            (parenthesized_expression
              (identifier))
            (indented_block
              (match_expression
                (identifier)
                (case_block
                  (case_clause
                    (integer_literal)
                    (integer_literal)))))
            (integer_literal))))
      (function_definition
        (identifier)
        (block
          (try_expression
            (if_expression
              (parenthesized_expression
                (identifier))
              (call_expression
                (field_expression
                  (identifier)
                  (identifier))
                (arguments
                  (identifier))))
            (finally_clause
              (if_expression
                (parenthesized_expression
                  (identifier))
                (call_expression
                  (field_expression
                    (identifier)
                    (identifier))
                  (arguments
                    (boolean_literal)))))))))))

================================================================================
Operator at end of line before an annotated definition
================================================================================

trait R {
  val optPos = "pos" --?
  @deprecated val g = 1
}

--------------------------------------------------------------------------------

(compilation_unit
  (trait_definition
    (identifier)
    (template_body
      (val_definition
        (identifier)
        (postfix_expression
          (string)
          (operator_identifier)))
      (val_definition
        (annotation
          (type_identifier))
        (identifier)
        (integer_literal)))))

================================================================================
Parenthesized for with do, yield on the next line, and a bare indented body
================================================================================

def f =
  for ((a, b) <- xs) do
    g(a)
  for (x <- xs)
    val y = h(x)
    k(y)
  for (param <- params; idx <- indices(param))
  yield param.name
  for (typearg <- tree.typeargs)
  do
    h(typearg)

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (for_expression
        (enumerators
          (enumerator
            (tuple_pattern
              (identifier)
              (identifier))
            (identifier)))
        (indented_block
          (call_expression
            (identifier)
            (arguments
              (identifier)))))
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (identifier)))
        (indented_block
          (val_definition
            (identifier)
            (call_expression
              (identifier)
              (arguments
                (identifier))))
          (call_expression
            (identifier)
            (arguments
              (identifier)))))
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (identifier))
          (enumerator
            (identifier)
            (call_expression
              (identifier)
              (arguments
                (identifier)))))
        (field_expression
          (identifier)
          (identifier)))
      (for_expression
        (enumerators
          (enumerator
            (identifier)
            (field_expression
              (identifier)
              (identifier))))
        (indented_block
          (call_expression
            (identifier)
            (arguments
              (identifier))))))))

================================================================================
Postfix operator at end of line before a definition keyword
================================================================================

trait RunnerSpec {
  val optPos = "pos" / "run compilation tests (success)" --?
  val optNeg = "neg" / "run compilation tests (failure)" --?
}

--------------------------------------------------------------------------------

(compilation_unit
  (trait_definition
    (identifier)
    (template_body
      (val_definition
        (identifier)
        (postfix_expression
          (infix_expression
            (string)
            (operator_identifier)
            (string))
          (operator_identifier)))
      (val_definition
        (identifier)
        (postfix_expression
          (infix_expression
            (string)
            (operator_identifier)
            (string))
          (operator_identifier))))))

================================================================================
Top-level match with cases at width zero and a following statement
================================================================================

x match
case 1 => a
case 2 => b
val z = 1

--------------------------------------------------------------------------------

(compilation_unit
  (match_expression
    (identifier)
    (indented_cases
      (case_clause
        (integer_literal)
        (identifier))
      (case_clause
        (integer_literal)
        (identifier))))
  (val_definition
    (identifier)
    (integer_literal)))

================================================================================
Trailing infix operator line continuation
================================================================================

def f = for {
  pipeline = a >>>
               b >>>
               c
  _ <- queue.take *>
         ref.update(g)
} yield pipeline

val cond =
  if (c) ???
  else d

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (for_expression
      (enumerators
        (enumerator
          (identifier)
          (infix_expression
            (infix_expression
              (identifier)
              (operator_identifier)
              (identifier))
            (operator_identifier)
            (identifier)))
        (enumerator
          (wildcard)
          (infix_expression
            (field_expression
              (identifier)
              (identifier))
            (operator_identifier)
            (call_expression
              (field_expression
                (identifier)
                (identifier))
              (arguments
                (identifier))))))
      (identifier)))
  (val_definition
    (identifier)
    (indented_block
      (if_expression
        (parenthesized_expression
          (identifier))
        (operator_identifier)
        (identifier)))))

================================================================================
Then condition holding a match (Scala 3 syntax)
================================================================================

val r =
  if xs match
    case Nil => false
    case _ => true
  then "y"
  else "n"

--------------------------------------------------------------------------------

(compilation_unit
  (val_definition
    (identifier)
    (indented_block
      (if_expression
        (match_expression
          (identifier)
          (indented_cases
            (case_clause
              (identifier)
              (boolean_literal))
            (case_clause
              (wildcard)
              (boolean_literal))))
        (string)
        (string)))))

================================================================================
While with a match condition and a line-leading do (Scala 3 syntax)
================================================================================

def w() =
  while (sArr(last): @switch) match
      case Sym => true
      case _ => false
  do last -= 1

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters)
    (indented_block
      (while_expression
        (match_expression
          (parenthesized_expression
            (ascription_expression
              (call_expression
                (identifier)
                (arguments
                  (identifier)))
              (annotation
                (type_identifier))))
          (indented_cases
            (case_clause
              (identifier)
              (boolean_literal))
            (case_clause
              (wildcard)
              (boolean_literal))))
        (infix_expression
          (identifier)
          (operator_identifier)
          (integer_literal))))))

================================================================================
Parenthesized while with a next-line body
================================================================================

def g() = {
  while (c)
    step()
}

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (parameters)
    (block
      (while_expression
        (parenthesized_expression
          (identifier))
        (call_expression
          (identifier)
          (arguments))))))

================================================================================
Curried typed lambda in braces (Scala 3 syntax)
================================================================================

val h = { x: Int => y: Int => x + y }

--------------------------------------------------------------------------------

(compilation_unit
  (val_definition
    (identifier)
    (block
      (lambda_expression
        (identifier)
        (type_identifier)
        (ascription_expression
          (identifier)
          (type_identifier)
          (infix_type
            (type_identifier)
            (operator_identifier)
            (type_identifier)))))))

================================================================================
Lambda takes the rest of an indented block (Scala 3 syntax)
================================================================================

object T:
  def f =
    run(x):
      implicit b =>
      import G.*
      compute(b)

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    name: (identifier)
    body: (template_body
      (function_definition
        name: (identifier)
        body: (indented_block
          (call_expression
            function: (call_expression
              function: (identifier)
              arguments: (arguments
                (identifier)))
            arguments: (colon_argument
              (indented_block
                (lambda_expression
                  parameters: (identifier)
                  (import_declaration
                    path: (identifier)
                    (namespace_wildcard))
                  (call_expression
                    function: (identifier)
                    arguments: (arguments
                      (identifier))))))))))))

================================================================================
Infix operator precedence (issue #218)
================================================================================

object X {
  a < b && c > d
  x :: y :: z
  n + m * k
  acc += n * 2
  p max q && r
}

--------------------------------------------------------------------------------

(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (infix_expression
        (infix_expression
          (identifier)
          (operator_identifier)
          (identifier))
        (operator_identifier)
        (infix_expression
          (identifier)
          (operator_identifier)
          (identifier)))
      (infix_expression
        (identifier)
        (operator_identifier)
        (infix_expression
          (identifier)
          (operator_identifier)
          (identifier)))
      (infix_expression
        (identifier)
        (operator_identifier)
        (infix_expression
          (identifier)
          (operator_identifier)
          (identifier)))
      (infix_expression
        (identifier)
        (operator_identifier)
        (infix_expression
          (identifier)
          (operator_identifier)
          (integer_literal)))
      (infix_expression
        (identifier)
        (identifier)
        (infix_expression
          (identifier)
          (operator_identifier)
          (identifier))))))

================================================================================
Empty quoted block
================================================================================

val a = '{}
val b = '{ x }

--------------------------------------------------------------------------------

(compilation_unit
  (val_definition
    (identifier)
    (quote_expression))
  (val_definition
    (identifier)
    (quote_expression
      (identifier))))

================================================================================
Fewer-braces colon after a dedented closing paren
================================================================================

def a =
  api
    .zip(
      b
        .map:
          x
        .map(s)
    )
    .map:
      case p => p

--------------------------------------------------------------------------------

(compilation_unit
  (function_definition
    (identifier)
    (indented_block
      (call_expression
        (field_expression
          (call_expression
            (field_expression
              (identifier)
              (identifier))
            (arguments
              (call_expression
                (field_expression
                  (call_expression
                    (field_expression
                      (identifier)
                      (identifier))
                    (colon_argument
                      (indented_block
                        (identifier))))
                  (identifier))
                (arguments
                  (identifier)))))
          (identifier))
        (colon_argument
          (indented_cases
            (case_clause
              (identifier)
              (identifier))))))))

================================================================================
Inline modifier at the end of its line (Scala 3)
================================================================================

object O:
  private[O] inline
  def isolated[T](inline op: Boolean) = op

  inline (a + b) match
    case _ => 3

--------------------------------------------------------------------------------
(compilation_unit
  (object_definition
    (identifier)
    (template_body
      (function_definition
        (modifiers
          (access_modifier
            (access_qualifier
              (identifier)))
          (inline_modifier))
        (identifier)
        (type_parameters
          (identifier))
        (parameters
          (parameter
            (inline_modifier)
            (identifier)
            (type_identifier)))
        (identifier))
      (match_expression
        (inline_modifier)
        (parenthesized_expression
          (infix_expression
            (identifier)
            (operator_identifier)
            (identifier)))
        (indented_cases
          (case_clause
            (wildcard)
            (integer_literal)))))))

================================================================================
A leading operator does not continue the line before a word that cannot start
an expression
================================================================================

class C {
  val a = 1
  ??? match {
    case _ => 2
  }
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (val_definition
        (identifier)
        (integer_literal))
      (match_expression
        (operator_identifier)
        (case_block
          (case_clause
            (wildcard)
            (integer_literal)))))))

================================================================================
A leading operator does not continue the line before a closing brace
================================================================================

class C {
  null
  ???
}

--------------------------------------------------------------------------------

(compilation_unit
  (class_definition
    (identifier)
    (template_body
      (null_literal)
      (operator_identifier))))
