===
Array literal
===

let xs = [1, 2, 3]

---

source_file
  statement:
    property_declaration
      binding:
        value_binding_pattern
          mutability: let
      declarator:
        property_binding
          name:
            pattern
              bound_identifier: simple_identifier "xs"
          value:
            array_literal
              element:
                integer_literal "1"
                integer_literal "2"
                integer_literal "3"

---

top_level
  body:
    block
      stmt:
        variable_declaration
          modifier: modifier "let"
          pattern:
            name_pattern
              identifier: identifier "xs"
          value:
            array_literal
              element:
                int_literal "1"
                int_literal "2"
                int_literal "3"

===
Empty array literal with type
===

let xs: [Int] = []

---

source_file
  statement:
    property_declaration
      binding:
        value_binding_pattern
          mutability: let
      declarator:
        property_binding
          name:
            pattern
              bound_identifier: simple_identifier "xs"
          type:
            type_annotation
              type:
                type
                  name:
                    array_type
                      element:
                        type
                          name:
                            user_type
                              part:
                                simple_user_type
                                  name: type_identifier "Int"
          value:
            array_literal

---

top_level
  body:
    block
      stmt:
        variable_declaration
          modifier: modifier "let"
          pattern:
            name_pattern
              identifier: identifier "xs"
          type:
            generic_type_expr
              base:
                named_type_expr
                  name: identifier "Array"
              type_argument:
                named_type_expr
                  name: identifier "Int"
          value: array_literal "[]"

===
Dictionary literal
===

let d = ["a": 1, "b": 2]

---

source_file
  statement:
    property_declaration
      binding:
        value_binding_pattern
          mutability: let
      declarator:
        property_binding
          name:
            pattern
              bound_identifier: simple_identifier "d"
          value:
            dictionary_literal
              element:
                dictionary_literal_item
                  key:
                    line_string_literal
                      text: line_str_text "a"
                  value: integer_literal "1"
                dictionary_literal_item
                  key:
                    line_string_literal
                      text: line_str_text "b"
                  value: integer_literal "2"

---

top_level
  body:
    block
      stmt:
        variable_declaration
          modifier: modifier "let"
          pattern:
            name_pattern
              identifier: identifier "d"
          value: map_literal "[\"a\": 1, \"b\": 2]"

===
Set literal
===

let s: Set<Int> = [1, 2, 3]

---

source_file
  statement:
    property_declaration
      binding:
        value_binding_pattern
          mutability: let
      declarator:
        property_binding
          name:
            pattern
              bound_identifier: simple_identifier "s"
          type:
            type_annotation
              type:
                type
                  name:
                    user_type
                      part:
                        simple_user_type
                          arguments:
                            type_arguments
                              argument:
                                type
                                  name:
                                    user_type
                                      part:
                                        simple_user_type
                                          name: type_identifier "Int"
                          name: type_identifier "Set"
          value:
            array_literal
              element:
                integer_literal "1"
                integer_literal "2"
                integer_literal "3"

---

top_level
  body:
    block
      stmt:
        variable_declaration
          modifier: modifier "let"
          pattern:
            name_pattern
              identifier: identifier "s"
          type:
            named_type_expr
              name: identifier "Set<Int>"
          value:
            array_literal
              element:
                int_literal "1"
                int_literal "2"
                int_literal "3"

===
Tuple literal
===

let t = (1, "two", 3.0)

---

source_file
  statement:
    property_declaration
      binding:
        value_binding_pattern
          mutability: let
      declarator:
        property_binding
          name:
            pattern
              bound_identifier: simple_identifier "t"
          value:
            tuple_expression
              element:
                tuple_expression_item
                  value: integer_literal "1"
                tuple_expression_item
                  value:
                    line_string_literal
                      text: line_str_text "two"
                tuple_expression_item
                  value: real_literal "3.0"

---

top_level
  body:
    block
      stmt:
        variable_declaration
          modifier: modifier "let"
          pattern:
            name_pattern
              identifier: identifier "t"
          value: tuple_expr "(1, \"two\", 3.0)"

===
Subscript access
===

// TODO: tree-sitter-swift parses `xs[0]` as a call_expression (same shape
// as `xs(0)`), so the mapping currently produces a call_expr. Update the
// parser / add a separate subscript_expr node and remap when fixed.
let first = xs[0]

---

source_file
  statement:
    property_declaration
      binding:
        value_binding_pattern
          mutability: let
      declarator:
        property_binding
          name:
            pattern
              bound_identifier: simple_identifier "first"
          value:
            call_expression
              function: simple_identifier "xs"
              suffix:
                call_suffix
                  arguments:
                    value_arguments
                      argument:
                        value_argument
                          value: integer_literal "0"
  comment "// TODO: tree-sitter-swift parses `xs[0]` as a call_expression (same shape"
  comment "// as `xs(0)`), so the mapping currently produces a call_expr. Update the"
  comment "// parser / add a separate subscript_expr node and remap when fixed."

---

top_level
  body:
    block
      stmt:
        variable_declaration
          modifier: modifier "let"
          pattern:
            name_pattern
              identifier: identifier "first"
          value:
            call_expr
              argument:
                argument
                  value: int_literal "0"
              callee:
                name_expr
                  identifier: identifier "xs"

===
Dictionary subscript
===

// TODO: same parser issue as the array subscript case above —
// `d["key"]` is parsed as `call_expression(d, ("key"))`.
let v = d["key"]

---

source_file
  statement:
    property_declaration
      binding:
        value_binding_pattern
          mutability: let
      declarator:
        property_binding
          name:
            pattern
              bound_identifier: simple_identifier "v"
          value:
            call_expression
              function: simple_identifier "d"
              suffix:
                call_suffix
                  arguments:
                    value_arguments
                      argument:
                        value_argument
                          value:
                            line_string_literal
                              text: line_str_text "key"
  comment "// TODO: same parser issue as the array subscript case above —"
  comment "// `d[\"key\"]` is parsed as `call_expression(d, (\"key\"))`."

---

top_level
  body:
    block
      stmt:
        variable_declaration
          modifier: modifier "let"
          pattern:
            name_pattern
              identifier: identifier "v"
          value:
            call_expr
              argument:
                argument
                  value: string_literal "\"key\""
              callee:
                name_expr
                  identifier: identifier "d"

===
Tuple member access
===

let n = t.0

---

source_file
  statement:
    property_declaration
      binding:
        value_binding_pattern
          mutability: let
      declarator:
        property_binding
          name:
            pattern
              bound_identifier: simple_identifier "n"
          value:
            navigation_expression
              suffix:
                navigation_suffix
                  suffix: integer_literal "0"
              target: simple_identifier "t"

---

top_level
  body:
    block
      stmt:
        variable_declaration
          modifier: modifier "let"
          pattern:
            name_pattern
              identifier: identifier "n"
          value:
            member_access_expr
              base:
                name_expr
                  identifier: identifier "t"
              member: identifier "0"
